#ifndef __DAO_QTCORE_H__
#define __DAO_QTCORE_H__
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<dao.h>
#include<QVector>
#include<QList>
#include<qfeatures.h>
#include<qfunctions_vxworks.h>
#include<qglobal.h>
#include<qiterator.h>
#include<qmath.h>
#include<qmutex.h>
#include<qnamespace.h>
#include<qnumeric.h>
#include<qobjectdefs.h>
#include<qpoint.h>
#include<qreadwritelock.h>
#include<qrunnable.h>
#include<qscopedpointer.h>
#include<qsemaphore.h>
#include<qsize.h>
#include<qtconcurrentcompilertest.h>
#include<qtconcurrentfunctionwrappers.h>
#include<qthreadstorage.h>
#include<qwaitcondition.h>
#include<qalgorithms.h>
#include<qbasicatomic.h>
#include<qbasictimer.h>
#include<qchar.h>
#include<qcontainerfwd.h>
#include<qeasingcurve.h>
#include<qelapsedtimer.h>
#include<qendian.h>
#include<qline.h>
#include<qmargins.h>
#include<qrect.h>
#include<qvarlengtharray.h>
#include<qatomic.h>
#include<qbytearray.h>
#include<qbytearraymatcher.h>
#include<qcontiguouscache.h>
#include<qcoreevent.h>
#include<qcryptographichash.h>
#include<qlinkedlist.h>
#include<qlist.h>
#include<qmap.h>
#include<qqueue.h>
#include<qshareddata.h>
#include<qsharedpointer.h>
#include<qstring.h>
#include<qstringmatcher.h>
#include<qsystemsemaphore.h>
#include<qtconcurrentexception.h>
#include<qtconcurrentresultstore.h>
#include<qtextboundaryfinder.h>
#include<qtextcodec.h>
#include<quuid.h>
#include<qvector.h>
#include<qbitarray.h>
#include<qdatetime.h>
#include<qfutureinterface.h>
#include<qlibraryinfo.h>
#include<qlocale.h>
#include<qobject.h>
#include<qobjectcleanuphandler.h>
#include<qpointer.h>
#include<qregexp.h>
#include<qsharedmemory.h>
#include<qsocketnotifier.h>
#include<qstack.h>
#include<qtconcurrentmedian.h>
#include<qthread.h>
#include<qthreadpool.h>
#include<qtimeline.h>
#include<qtimer.h>
#include<qtranslator.h>
#include<qabstractanimation.h>
#include<qabstractstate.h>
#include<qabstracttransition.h>
#include<qanimationgroup.h>
#include<qeventloop.h>
#include<qeventtransition.h>
#include<qfilesystemwatcher.h>
#include<qfinalstate.h>
#include<qfuture.h>
#include<qfuturesynchronizer.h>
#include<qfuturewatcher.h>
#include<qhistorystate.h>
#include<qiodevice.h>
#include<qlibrary.h>
#include<qparallelanimationgroup.h>
#include<qpauseanimation.h>
#include<qplugin.h>
#include<qpluginloader.h>
#include<qsequentialanimationgroup.h>
#include<qsignaltransition.h>
#include<qstate.h>
#include<qtconcurrentreducekernel.h>
#include<qtconcurrentrunbase.h>
#include<qtconcurrentstoredfunctioncall.h>
#include<qtconcurrentthreadengine.h>
#include<qtextstream.h>
#include<qxmlstream.h>
#include<qabstracteventdispatcher.h>
#include<qbuffer.h>
#include<qdatastream.h>
#include<qfile.h>
#include<qfileinfo.h>
#include<qmetatype.h>
#include<qpair.h>
#include<qstringlist.h>
#include<qtconcurrentiteratekernel.h>
#include<qtconcurrentmapkernel.h>
#include<qtconcurrentrun.h>
#include<qtemporaryfile.h>
#include<qcoreapplication.h>
#include<qdir.h>
#include<qdiriterator.h>
#include<qfactoryinterface.h>
#include<qhash.h>
#include<qprocess.h>
#include<qresource.h>
#include<qset.h>
#include<qtconcurrentfilterkernel.h>
#include<qtconcurrentmap.h>
#include<qtextcodecplugin.h>
#include<qurl.h>
#include<qvariant.h>
#include<qvariantanimation.h>
#include<qabstractfileengine.h>
#include<qabstractitemmodel.h>
#include<qcache.h>
#include<qfsfileengine.h>
#include<qmetaobject.h>
#include<qmimedata.h>
#include<qpropertyanimation.h>
#include<qsettings.h>
#include<qstatemachine.h>
#include<qtconcurrentfilter.h>
#ifndef DAO_QTCORE_STATIC
#ifndef DAO_DLL_QTCORE
#define DAO_DLL_QTCORE DAO_DLL_EXPORT
#endif
#else
#define DAO_DLL_QTCORE
#endif

extern DaoVmSpace *__daoVmSpace;

#ifdef __cplusplus
extern "C"{
#endif

extern DaoTypeBase *dao_Access_Typer;
extern DaoTypeBase *dao_AccessMode_Typer;
extern DaoTypeBase *dao_Algorithm_Typer;
extern DaoTypeBase *dao_BlockSizeManager_Typer;
extern DaoTypeBase *dao_BoundaryType_Typer;
extern DaoTypeBase *dao_Call_Typer;
extern DaoTypeBase *dao_CaretMode_Typer;
extern DaoTypeBase *dao_Category_Typer;
extern DaoTypeBase *dao_ChildMode_Typer;
extern DaoTypeBase *dao_ClockType_Typer;
extern DaoTypeBase *dao_Container_Typer;
extern DaoTypeBase *dao_Country_Typer;
extern DaoTypeBase *dao_CurveShape_Typer;
extern DaoTypeBase *dao_Decomposition_Typer;
extern DaoTypeBase *dao_Direction_Typer;
extern DaoTypeBase *dao_Encoding_Typer;
extern DaoTypeBase *dao_EntryInfoType_Typer;
extern DaoTypeBase *dao_Error_Typer;
extern DaoTypeBase *dao_EventPriority_Typer;
extern DaoTypeBase *dao_Extension_Typer;
extern DaoTypeBase *dao_FieldAlignment_Typer;
extern DaoTypeBase *dao_FileError_Typer;
extern DaoTypeBase *dao_FileFlags_Typer;
extern DaoTypeBase *dao_FileName_Typer;
extern DaoTypeBase *dao_FileOwner_Typer;
extern DaoTypeBase *dao_FileTime_Typer;
extern DaoTypeBase *dao_Format_Typer;
extern DaoTypeBase *dao_FormatType_Typer;
extern DaoTypeBase *dao_HistoryType_Typer;
extern DaoTypeBase *dao_IntersectType_Typer;
extern DaoTypeBase *dao_Iterator_Typer;
extern DaoTypeBase *dao_Joining_Typer;
extern DaoTypeBase *dao_Language_Typer;
extern DaoTypeBase *dao_LibraryLocation_Typer;
extern DaoTypeBase *dao_MeasurementSystem_Typer;
extern DaoTypeBase *dao_MemoryMapFlags_Typer;
extern DaoTypeBase *dao_MethodType_Typer;
extern DaoTypeBase *dao_MonthNameType_Typer;
extern DaoTypeBase *dao_NormalizationForm_Typer;
extern DaoTypeBase *dao_OpenMode_Typer;
extern DaoTypeBase *dao_ParsingMode_Typer;
extern DaoTypeBase *dao_PatternSyntax_Typer;
extern DaoTypeBase *dao_Priority_Typer;
extern DaoTypeBase *dao_ProcessChannel_Typer;
extern DaoTypeBase *dao_ProcessChannelMode_Typer;
extern DaoTypeBase *dao_ProcessState_Typer;
extern DaoTypeBase *dao_QObject_Typer;
extern DaoTypeBase *dao_QAbstractAnimation_Typer;
extern DaoTypeBase *dao_QAbstractAnimationPrivate_Typer;
extern DaoTypeBase *dao_QAbstractEventDispatcher_Typer;
extern DaoTypeBase *dao_QAbstractEventDispatcher_EventFilter_Typer;
extern DaoTypeBase *dao_QAbstractEventDispatcher_EventFilter_x_Typer;
extern DaoTypeBase *dao_QAbstractEventDispatcher_TimerInfo_Typer;
extern DaoTypeBase *dao_QAbstractEventDispatcherPrivate_Typer;
extern DaoTypeBase *dao_QAbstractFileEngine_Typer;
extern DaoTypeBase *dao_QAbstractFileEngine_ExtensionOption_Typer;
extern DaoTypeBase *dao_QAbstractFileEngine_ExtensionReturn_Typer;
extern DaoTypeBase *dao_QAbstractFileEngine_Iterator_Typer;
extern DaoTypeBase *dao_QAbstractFileEngine_MapExtensionOption_Typer;
extern DaoTypeBase *dao_QAbstractFileEngine_MapExtensionReturn_Typer;
extern DaoTypeBase *dao_QAbstractFileEngine_UnMapExtensionOption_Typer;
extern DaoTypeBase *dao_QAbstractFileEngineHandler_Typer;
extern DaoTypeBase *dao_QAbstractFileEngineIterator_Typer;
extern DaoTypeBase *dao_QAbstractFileEnginePrivate_Typer;
extern DaoTypeBase *dao_QAbstractItemModel_Typer;
extern DaoTypeBase *dao_QAbstractItemModelPrivate_Typer;
extern DaoTypeBase *dao_QAbstractListModel_Typer;
extern DaoTypeBase *dao_QAbstractState_Typer;
extern DaoTypeBase *dao_QAbstractStatePrivate_Typer;
extern DaoTypeBase *dao_QAbstractTableModel_Typer;
extern DaoTypeBase *dao_QAbstractTransition_Typer;
extern DaoTypeBase *dao_QAbstractTransitionPrivate_Typer;
extern DaoTypeBase *dao_QAnimationGroup_Typer;
extern DaoTypeBase *dao_QAnimationGroupPrivate_Typer;
extern DaoTypeBase *dao_QBasicAtomicInt_Typer;
extern DaoTypeBase *dao_QAtomicInt_Typer;
extern DaoTypeBase *dao_QBasicTimer_Typer;
extern DaoTypeBase *dao_QBitArray_Typer;
extern DaoTypeBase *dao_QByteArray_DataPtr_Typer;
extern DaoTypeBase *dao_QBool_Typer;
extern DaoTypeBase *dao_QIODevice_Typer;
extern DaoTypeBase *dao_QBuffer_Typer;
extern DaoTypeBase *dao_QByteArray_Typer;
extern DaoTypeBase *dao_QByteArray_ConstIterator_Typer;
extern DaoTypeBase *dao_QByteArray_Data_Typer;
extern DaoTypeBase *dao_QByteArray_Iterator_Typer;
extern DaoTypeBase *dao_QByteArray_const_iterator_Typer;
extern DaoTypeBase *dao_QByteArray_const_reference_Typer;
extern DaoTypeBase *dao_QByteArray_iterator_Typer;
extern DaoTypeBase *dao_QByteArray_reference_Typer;
extern DaoTypeBase *dao_QByteArrayMatcher_Typer;
extern DaoTypeBase *dao_QByteArrayMatcher_Data_Typer;
extern DaoTypeBase *dao_QChar_Typer;
extern DaoTypeBase *dao_QEvent_Typer;
extern DaoTypeBase *dao_QChildEvent_Typer;
extern DaoTypeBase *dao_QContiguousCacheData_Typer;
extern DaoTypeBase *dao_QCoreApplication_Typer;
extern DaoTypeBase *dao_QCoreApplication_EventFilter_Typer;
extern DaoTypeBase *dao_QCoreApplication_EventFilter_x_Typer;
extern DaoTypeBase *dao_QCoreApplicationPrivate_Typer;
extern DaoTypeBase *dao_QCryptographicHash_Typer;
extern DaoTypeBase *dao_QDataStream_Typer;
extern DaoTypeBase *dao_QDate_Typer;
extern DaoTypeBase *dao_QDateTime_Typer;
extern DaoTypeBase *dao_QDir_Typer;
extern DaoTypeBase *dao_QDirIterator_Typer;
extern DaoTypeBase *dao_QDynamicPropertyChangeEvent_Typer;
extern DaoTypeBase *dao_QEasingCurve_Typer;
extern DaoTypeBase *dao_QEasingCurve_EasingFunction_Typer;
extern DaoTypeBase *dao_QEasingCurve_EasingFunction_x_Typer;
extern DaoTypeBase *dao_QElapsedTimer_Typer;
extern DaoTypeBase *dao_QEventLoop_Typer;
extern DaoTypeBase *dao_QEventTransition_Typer;
extern DaoTypeBase *dao_QEventTransitionPrivate_Typer;
extern DaoTypeBase *dao_QFSFileEngine_Typer;
extern DaoTypeBase *dao_QFSFileEnginePrivate_Typer;
extern DaoTypeBase *dao_QFactoryInterface_Typer;
extern DaoTypeBase *dao_QFile_Typer;
extern DaoTypeBase *dao_QFile_DecoderFn_Typer;
extern DaoTypeBase *dao_QFile_DecoderFn_x_Typer;
extern DaoTypeBase *dao_QFile_EncoderFn_Typer;
extern DaoTypeBase *dao_QFile_EncoderFn_x_Typer;
extern DaoTypeBase *dao_QFileInfo_Typer;
extern DaoTypeBase *dao_QFileInfoList_Typer;
extern DaoTypeBase *dao_QFileInfoPrivate_Typer;
extern DaoTypeBase *dao_QFilePrivate_Typer;
extern DaoTypeBase *dao_QFileSystemWatcher_Typer;
extern DaoTypeBase *dao_QFinalState_Typer;
extern DaoTypeBase *dao_QFutureInterfaceBase_Typer;
extern DaoTypeBase *dao_QFutureWatcherBase_Typer;
extern DaoTypeBase *dao_QGenericArgument_Typer;
extern DaoTypeBase *dao_QGenericReturnArgument_Typer;
extern DaoTypeBase *dao_QHashData_Typer;
extern DaoTypeBase *dao_QHashData_Node_Typer;
extern DaoTypeBase *dao_QHashDummyValue_Typer;
extern DaoTypeBase *dao_QHistoryState_Typer;
extern DaoTypeBase *dao_QIODevicePrivate_Typer;
extern DaoTypeBase *dao_QLatin1Char_Typer;
extern DaoTypeBase *dao_QLatin1String_Typer;
extern DaoTypeBase *dao_QLibrary_Typer;
extern DaoTypeBase *dao_QLibraryInfo_Typer;
extern DaoTypeBase *dao_QLine_Typer;
extern DaoTypeBase *dao_QLineF_Typer;
extern DaoTypeBase *dao_QLinkedListData_Typer;
extern DaoTypeBase *dao_QListData_Typer;
extern DaoTypeBase *dao_QListData_Data_Typer;
extern DaoTypeBase *dao_QLocale_Typer;
extern DaoTypeBase *dao_QLocale_Data_Typer;
extern DaoTypeBase *dao_QLocalePrivate_Typer;
extern DaoTypeBase *dao_QMapData_Typer;
extern DaoTypeBase *dao_QMapData_Node_Typer;
extern DaoTypeBase *dao_QMetaClassInfo_Typer;
extern DaoTypeBase *dao_QMetaEnum_Typer;
extern DaoTypeBase *dao_QMetaMethod_Typer;
extern DaoTypeBase *dao_QMetaObject_Typer;
extern DaoTypeBase *dao_QMetaObjectExtraData_Typer;
extern DaoTypeBase *dao_QMetaProperty_Typer;
extern DaoTypeBase *dao_QMetaType_Typer;
extern DaoTypeBase *dao_QMetaType_Constructor_Typer;
extern DaoTypeBase *dao_QMetaType_Constructor_x_Typer;
extern DaoTypeBase *dao_QMetaType_Destructor_Typer;
extern DaoTypeBase *dao_QMetaType_Destructor_x_Typer;
extern DaoTypeBase *dao_QMetaType_LoadOperator_Typer;
extern DaoTypeBase *dao_QMetaType_LoadOperator_x_Typer;
extern DaoTypeBase *dao_QMetaType_SaveOperator_Typer;
extern DaoTypeBase *dao_QMetaType_SaveOperator_x_Typer;
extern DaoTypeBase *dao_QMimeData_Typer;
extern DaoTypeBase *dao_QModelIndex_Typer;
extern DaoTypeBase *dao_QModelIndexList_Typer;
extern DaoTypeBase *dao_QMutex_Typer;
extern DaoTypeBase *dao_QMutexLocker_Typer;
extern DaoTypeBase *dao_QObjectCleanupHandler_Typer;
extern DaoTypeBase *dao_QObjectData_Typer;
extern DaoTypeBase *dao_QObjectList_Typer;
extern DaoTypeBase *dao_QObjectPrivate_Typer;
extern DaoTypeBase *dao_QParallelAnimationGroup_Typer;
extern DaoTypeBase *dao_QParallelAnimationGroupPrivate_Typer;
extern DaoTypeBase *dao_QPauseAnimation_Typer;
extern DaoTypeBase *dao_QPersistentModelIndex_Typer;
extern DaoTypeBase *dao_QPluginLoader_Typer;
extern DaoTypeBase *dao_QPoint_Typer;
extern DaoTypeBase *dao_QPointF_Typer;
extern DaoTypeBase *dao_QPostEventList_Typer;
extern DaoTypeBase *dao_QProcess_Typer;
extern DaoTypeBase *dao_QProcessEnvironment_Typer;
extern DaoTypeBase *dao_QVariantAnimation_Typer;
extern DaoTypeBase *dao_QPropertyAnimation_Typer;
extern DaoTypeBase *dao_QReadLocker_Typer;
extern DaoTypeBase *dao_QReadWriteLock_Typer;
extern DaoTypeBase *dao_QRect_Typer;
extern DaoTypeBase *dao_QRectF_Typer;
extern DaoTypeBase *dao_QRegExp_Typer;
extern DaoTypeBase *dao_QResource_Typer;
extern DaoTypeBase *dao_QRunnable_Typer;
extern DaoTypeBase *dao_QScopedPointerPodDeleter_Typer;
extern DaoTypeBase *dao_QSemaphore_Typer;
extern DaoTypeBase *dao_QSequentialAnimationGroup_Typer;
extern DaoTypeBase *dao_QSequentialAnimationGroupPrivate_Typer;
extern DaoTypeBase *dao_QSettings_Typer;
extern DaoTypeBase *dao_QSettings_ReadFunc_Typer;
extern DaoTypeBase *dao_QSettings_ReadFunc_x_Typer;
extern DaoTypeBase *dao_QSettings_SettingsMap_Typer;
extern DaoTypeBase *dao_QSettings_WriteFunc_Typer;
extern DaoTypeBase *dao_QSettings_WriteFunc_x_Typer;
extern DaoTypeBase *dao_QSharedData_Typer;
extern DaoTypeBase *dao_QSharedMemory_Typer;
extern DaoTypeBase *dao_QSignalTransition_Typer;
extern DaoTypeBase *dao_QSize_Typer;
extern DaoTypeBase *dao_QSizeF_Typer;
extern DaoTypeBase *dao_QSocketNotifier_Typer;
extern DaoTypeBase *dao_QState_Typer;
extern DaoTypeBase *dao_QStateMachine_Typer;
extern DaoTypeBase *dao_QStateMachine_SignalEvent_Typer;
extern DaoTypeBase *dao_QStateMachine_WrappedEvent_Typer;
extern DaoTypeBase *dao_QStateMachinePrivate_Typer;
extern DaoTypeBase *dao_QStatePrivate_Typer;
extern DaoTypeBase *dao_QString_Typer;
extern DaoTypeBase *dao_QString_ConstIterator_Typer;
extern DaoTypeBase *dao_QString_Data_Typer;
extern DaoTypeBase *dao_QString_DataPtr_Typer;
extern DaoTypeBase *dao_QString_Iterator_Typer;
extern DaoTypeBase *dao_QString_Null_Typer;
extern DaoTypeBase *dao_QString_const_iterator_Typer;
extern DaoTypeBase *dao_QString_iterator_Typer;
extern DaoTypeBase *dao_QStringList_Typer;
extern DaoTypeBase *dao_QStringMatcher_Typer;
extern DaoTypeBase *dao_QStringMatcher_Data_Typer;
extern DaoTypeBase *dao_QStringRef_Typer;
extern DaoTypeBase *dao_QSystemLocale_Typer;
extern DaoTypeBase *dao_QSystemSemaphore_Typer;
extern DaoTypeBase *dao_QTSMFC_Typer;
extern DaoTypeBase *dao_QTSMFI_Typer;
extern DaoTypeBase *dao_QTemporaryFile_Typer;
extern DaoTypeBase *dao_QTextBoundaryFinder_Typer;
extern DaoTypeBase *dao_QTextCodec_Typer;
extern DaoTypeBase *dao_QTextCodec_ConverterState_Typer;
extern DaoTypeBase *dao_QTextCodecFactoryInterface_Typer;
extern DaoTypeBase *dao_QTextCodecPlugin_Typer;
extern DaoTypeBase *dao_QTextDecoder_Typer;
extern DaoTypeBase *dao_QTextEncoder_Typer;
extern DaoTypeBase *dao_QTextStream_Typer;
extern DaoTypeBase *dao_QTextStreamManipulator_Typer;
extern DaoTypeBase *dao_QThread_Typer;
extern DaoTypeBase *dao_QThreadPool_Typer;
extern DaoTypeBase *dao_QThreadPrivate_Typer;
extern DaoTypeBase *dao_QThreadStorageData_Typer;
extern DaoTypeBase *dao_QTime_Typer;
extern DaoTypeBase *dao_QTimeLine_Typer;
extern DaoTypeBase *dao_QTimer_Typer;
extern DaoTypeBase *dao_QTimerEvent_Typer;
extern DaoTypeBase *dao_QTranslator_Typer;
extern DaoTypeBase *dao_QUrl_Typer;
extern DaoTypeBase *dao_QUrl_DataPtr_Typer;
extern DaoTypeBase *dao_QUuid_Typer;
extern DaoTypeBase *dao_QVariant_Typer;
extern DaoTypeBase *dao_QVariant_DataPtr_Typer;
extern DaoTypeBase *dao_QVariant_Handler_Typer;
extern DaoTypeBase *dao_QVariant_Private_Typer;
extern DaoTypeBase *dao_QVariant_PrivateShared_Typer;
extern DaoTypeBase *dao_QVariant_f_canConvert_Typer;
extern DaoTypeBase *dao_QVariant_f_canConvert_x_Typer;
extern DaoTypeBase *dao_QVariant_f_clear_Typer;
extern DaoTypeBase *dao_QVariant_f_clear_x_Typer;
extern DaoTypeBase *dao_QVariant_f_compare_Typer;
extern DaoTypeBase *dao_QVariant_f_compare_x_Typer;
extern DaoTypeBase *dao_QVariant_f_construct_Typer;
extern DaoTypeBase *dao_QVariant_f_construct_x_Typer;
extern DaoTypeBase *dao_QVariant_f_convert_Typer;
extern DaoTypeBase *dao_QVariant_f_convert_x_Typer;
extern DaoTypeBase *dao_QVariant_f_debugStream_Typer;
extern DaoTypeBase *dao_QVariant_f_debugStream_x_Typer;
extern DaoTypeBase *dao_QVariant_f_load_Typer;
extern DaoTypeBase *dao_QVariant_f_load_x_Typer;
extern DaoTypeBase *dao_QVariant_f_null_Typer;
extern DaoTypeBase *dao_QVariant_f_null_x_Typer;
extern DaoTypeBase *dao_QVariant_f_save_Typer;
extern DaoTypeBase *dao_QVariant_f_save_x_Typer;
extern DaoTypeBase *dao_QVariantAnimation_Interpolator_Typer;
extern DaoTypeBase *dao_QVariantAnimation_Interpolator_x_Typer;
extern DaoTypeBase *dao_QVariantAnimation_KeyValue_Typer;
extern DaoTypeBase *dao_QVariantAnimation_KeyValues_Typer;
extern DaoTypeBase *dao_QVariantAnimationPrivate_Typer;
extern DaoTypeBase *dao_QVectorData_Typer;
extern DaoTypeBase *dao_QWaitCondition_Typer;
extern DaoTypeBase *dao_QWriteLocker_Typer;
extern DaoTypeBase *dao_QXmlStreamAttribute_Typer;
extern DaoTypeBase *dao_QXmlStreamAttributes_Typer;
extern DaoTypeBase *dao_QXmlStreamEntityDeclaration_Typer;
extern DaoTypeBase *dao_QXmlStreamEntityDeclarations_Typer;
extern DaoTypeBase *dao_QXmlStreamEntityResolver_Typer;
extern DaoTypeBase *dao_QXmlStreamNamespaceDeclaration_Typer;
extern DaoTypeBase *dao_QXmlStreamNamespaceDeclarations_Typer;
extern DaoTypeBase *dao_QXmlStreamNotationDeclaration_Typer;
extern DaoTypeBase *dao_QXmlStreamNotationDeclarations_Typer;
extern DaoTypeBase *dao_QXmlStreamReader_Typer;
extern DaoTypeBase *dao_QXmlStreamStringRef_Typer;
extern DaoTypeBase *dao_QXmlStreamWriter_Typer;
extern DaoTypeBase *dao_Q_GADGET_Typer;
extern DaoTypeBase *dao_Q_PID_Typer;
extern DaoTypeBase *dao_Qt_WFlags_Typer;
extern DaoTypeBase *dao_QtConcurrent_ConstMemberFunctionWrapper_Typer;
extern DaoTypeBase *dao_QtConcurrent_FilterKernel_Typer;
extern DaoTypeBase *dao_QtConcurrent_FilteredEachKernel_Typer;
extern DaoTypeBase *dao_QtConcurrent_FilteredReducedKernel_Typer;
extern DaoTypeBase *dao_QtConcurrent_FunctionWrapper0_Typer;
extern DaoTypeBase *dao_QtConcurrent_FunctionWrapper1_Typer;
extern DaoTypeBase *dao_QtConcurrent_FunctionWrapper2_Typer;
extern DaoTypeBase *dao_QtConcurrent_IntermediateResults_Typer;
extern DaoTypeBase *dao_QtConcurrent_IterateKernel_Typer;
extern DaoTypeBase *dao_QtConcurrent_MapKernel_Typer;
extern DaoTypeBase *dao_QtConcurrent_MappedEachKernel_Typer;
extern DaoTypeBase *dao_QtConcurrent_MappedReducedKernel_Typer;
extern DaoTypeBase *dao_QtConcurrent_Median_Typer;
extern DaoTypeBase *dao_QtConcurrent_MemberFunctionWrapper_Typer;
extern DaoTypeBase *dao_QtConcurrent_MemberFunctionWrapper1_Typer;
extern DaoTypeBase *dao_QtConcurrent_ReduceKernel_Typer;
extern DaoTypeBase *dao_QtConcurrent_ResultItem_Typer;
extern DaoTypeBase *dao_QtConcurrent_ResultIterator_Typer;
extern DaoTypeBase *dao_QtConcurrent_ResultReporter_Typer;
extern DaoTypeBase *dao_QtConcurrent_ResultStore_Typer;
extern DaoTypeBase *dao_QtConcurrent_RunFunctionTask_Typer;
extern DaoTypeBase *dao_QtConcurrent_RunFunctionTaskBase_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredConstMemberFunctionCall0_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredConstMemberFunctionCall1_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredConstMemberFunctionCall2_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredConstMemberFunctionCall3_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredConstMemberFunctionCall4_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredConstMemberFunctionCall5_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredConstMemberFunctionPointerCall0_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredConstMemberFunctionPointerCall1_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredConstMemberFunctionPointerCall2_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredConstMemberFunctionPointerCall3_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredConstMemberFunctionPointerCall4_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredConstMemberFunctionPointerCall5_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredMemberFunctionCall0_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredMemberFunctionCall1_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredMemberFunctionCall2_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredMemberFunctionCall3_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredMemberFunctionCall4_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredMemberFunctionCall5_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredMemberFunctionPointerCall0_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredMemberFunctionPointerCall1_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredMemberFunctionPointerCall2_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredMemberFunctionPointerCall3_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredMemberFunctionPointerCall4_Typer;
extern DaoTypeBase *dao_QtConcurrent_StoredMemberFunctionPointerCall5_Typer;
extern DaoTypeBase *dao_QtConcurrent_ThreadEngine_Typer;
extern DaoTypeBase *dao_QtConcurrent_ThreadEngineBarrier_Typer;
extern DaoTypeBase *dao_QtConcurrent_ThreadEngineStarter_Typer;
extern DaoTypeBase *dao_QtConcurrent_ThreadEngineStarterBase_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredConstMemberFunctionCall0_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredConstMemberFunctionCall1_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredConstMemberFunctionCall2_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredConstMemberFunctionCall3_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredConstMemberFunctionCall4_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredConstMemberFunctionCall5_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredConstMemberFunctionPointerCall0_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredConstMemberFunctionPointerCall1_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredConstMemberFunctionPointerCall2_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredConstMemberFunctionPointerCall3_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredConstMemberFunctionPointerCall4_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredConstMemberFunctionPointerCall5_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredMemberFunctionCall0_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredMemberFunctionCall1_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredMemberFunctionCall2_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredMemberFunctionCall3_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredMemberFunctionCall4_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredMemberFunctionCall5_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredMemberFunctionPointerCall0_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredMemberFunctionPointerCall1_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredMemberFunctionPointerCall2_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredMemberFunctionPointerCall3_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredMemberFunctionPointerCall4_Typer;
extern DaoTypeBase *dao_QtConcurrent_VoidStoredMemberFunctionPointerCall5_Typer;
extern DaoTypeBase *dao_QueryType_Typer;
extern DaoTypeBase *dao_READ_Typer;
extern DaoTypeBase *dao_ReadElementTextBehaviour_Typer;
extern DaoTypeBase *dao_RealNumberNotation_Typer;
extern DaoTypeBase *dao_RecursionMode_Typer;
extern DaoTypeBase *dao_ResultItem_Typer;
extern DaoTypeBase *dao_ResultIteratorBase_Typer;
extern DaoTypeBase *dao_ResultStoreBase_Typer;
extern DaoTypeBase *dao_Scope_Typer;
extern DaoTypeBase *dao_SharedMemoryError_Typer;
extern DaoTypeBase *dao_SpecialCharacter_Typer;
extern DaoTypeBase *dao_SplitBehavior_Typer;
extern DaoTypeBase *dao_State_Typer;
extern DaoTypeBase *dao_Status_Typer;
extern DaoTypeBase *dao_SystemSemaphoreError_Typer;
extern DaoTypeBase *dao_T_Typer;
extern DaoTypeBase *dao_ThreadEngineBase_Typer;
extern DaoTypeBase *dao_ThreadFunctionResult_Typer;
extern DaoTypeBase *dao_TokenType_Typer;
extern DaoTypeBase *dao_Type_Typer;
extern DaoTypeBase *dao_UnicodeVersion_Typer;
extern DaoTypeBase *dao_WRITE_Typer;
extern DaoTypeBase *dao__QLinkedList_Typer;
extern DaoTypeBase *dao__QList_Typer;
extern DaoTypeBase *dao_operator2_Typer;
extern DaoTypeBase *dao_pragma_Typer;
extern DaoTypeBase *dao_template_Typer;
extern DaoTypeBase *dao_va_list_Typer;
#ifdef __cplusplus
}
#endif

namespace QtConcurrent{


BlockSizeManager* DAO_DLL_QTCORE Dao_BlockSizeManager_New( int iterationCount );
}

#include<QHash>
#define DAOQT_MAX_VALUE 16
class DaoQtMessage
{
  void Init( int n ){
    count = n;
    memset( p1, 0, DAOQT_MAX_VALUE * sizeof(DValue) );
    for(int i=0; i<DAOQT_MAX_VALUE; i++) p2[i] = p1 + i;
  }
  public:
  int     count;
  DValue  p1[DAOQT_MAX_VALUE];
  DValue *p2[DAOQT_MAX_VALUE];
  DaoQtMessage( int n=0 ){ Init( n ); }
  DaoQtMessage( const DaoQtMessage & other ){
    Init( other.count );
    for(int i=0; i<count; i++) DValue_Copy( p2[i], other.p1[i] );
  }
  ~DaoQtMessage(){ DValue_ClearAll( p1, count ); }
};
Q_DECLARE_METATYPE( DaoQtMessage )
class DaoQtObject : public QObjectUserData
{
	public:
	QHash<void*,QHash<void*,DValue> > mapRefers;
	QHash<QString,QHash<void*,DValue> > mapNames;
	DaoCData  *cdata;
	void Init( DaoCData *d ){ cdata = d; }
	static unsigned int RotatingHash( const QByteArray & key ){
		int i, n = key.size();
		unsigned long long hash = n;
		for(i=0; i<n; i++) hash = ((hash<<4)^(hash>>28)^key[i])&0x7fffffff;
		return hash % 997;
	}
	void Connect( void *sender, const QString & signal, DValue receiver )
	{
		if( mapNames.find( signal ) == mapNames.end() )
			mapNames[ signal ] = QHash<void*,DValue>();
		mapNames[ signal ][ sender ] = receiver;
	}
	void Connect( void *sender, void *signal, DValue receiver )
	{
		if( mapRefers.find( signal ) == mapRefers.end() )
			mapRefers[ signal ] = QHash<void*,DValue>();
		mapRefers[ signal ][ sender ] = receiver;
	}
	void Dispatch( void *sender, const QString &signal, const DaoQtMessage & msg )
	{
		if( mapNames.find( signal ) == mapNames.end() ) return;
		QHash<void*,DValue> & mp = mapNames[signal];
		if( mp.find( sender ) == mp.end() ) return;
		if( cdata == NULL ) return;
		DaoObject *daobj = DaoCData_GetObject( cdata );
		DValue receiver = mp[sender];
		DaoVmProcess *vmproc = DaoVmSpace_AcquireProcess( __daoVmSpace );
		if( receiver.t >= DAO_METAROUTINE && receiver.t <= DAO_FUNCTION ){
			DValue obj = {DAO_OBJECT,0,0,0,{0}};
			obj.v.object = daobj;
			DaoVmProcess_Call( vmproc, (DaoMethod*)receiver.v.p, &obj, (DValue**)msg.p2, msg.count );
		}
		DaoVmSpace_ReleaseProcess( __daoVmSpace, vmproc );
	}
	void Dispatch( void *sender, void *signal, const DaoQtMessage & msg )
	{
		if( mapRefers.find( signal ) == mapRefers.end() ) return;
		QHash<void*,DValue> & mp = mapRefers[signal];
		if( mp.find( sender ) == mp.end() ) return;
		if( cdata == NULL ) return;
		DaoObject *daobj = DaoCData_GetObject( cdata );
		DValue receiver = mp[sender];
		DaoVmProcess *vmproc = DaoVmSpace_AcquireProcess( __daoVmSpace );
		if( receiver.t >= DAO_METAROUTINE && receiver.t <= DAO_FUNCTION ){
			DValue obj = {DAO_OBJECT,0,0,0,{0}};
			obj.v.object = daobj;
			DaoVmProcess_Call( vmproc, (DaoMethod*)receiver.v.p, &obj, (DValue**)msg.p2, msg.count );
		}
		DaoVmSpace_ReleaseProcess( __daoVmSpace, vmproc );
	}
};
void DAO_DLL_QTCORE Dao_QObject_InitSS( QObject *p );
class DAO_DLL_QTCORE DaoSS_QObject : public QObject, public DaoQtObject
{ Q_OBJECT
public:
	DaoSS_QObject()  {}
	void Emit( void *o, void *s, const DaoQtMessage &m ){ emit signalDao( o, s, m ); }

public slots:
	void slotDaoQt( void*o, const QString&s, const DaoQtMessage &m ){ Dispatch(o,s,m); }
	void slotDao( void *o, void *s, const DaoQtMessage &m ){ Dispatch( o, s, m ); }
   void slot_deleteLater592( void*, void*, const DaoQtMessage& );
   void slot_destroyed788( QObject* _cp0 = 0 );

signals:
	void signalDao( void *o, void *s, const DaoQtMessage &m );
	void signalDaoQt( void*, const QString&, const DaoQtMessage &m );
   void signal_deleteLater592();
   void signal_destroyed788(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QObject 
{
	public:
	DaoCxxVirt_QObject(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QObject *self, DaoCData *d );
	QObject *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QObject : public QObject, public DaoCxxVirt_QObject
{ Q_OBJECT
	public:
   DaoCxx_QObject( QObject* parent=0 ) : QObject( parent ){}
   DaoCxx_QObject( QObjectPrivate &dd, QObject* parent = 0 ) : QObject( dd, parent ){}
	~DaoCxx_QObject();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
	void DaoWrap_childEvent( QChildEvent* _cp0 ){ QObject::childEvent( _cp0 ); }
	void DaoWrap_connectNotify( const char* signal ){ QObject::connectNotify( signal ); }
	void DaoWrap_customEvent( QEvent* _cp0 ){ QObject::customEvent( _cp0 ); }
	void DaoWrap_disconnectNotify( const char* signal ){ QObject::disconnectNotify( signal ); }
	int DaoWrap_receivers( const char* signal )const{ return QObject::receivers( signal ); }
	QObject* DaoWrap_sender(  )const{ return QObject::sender(  ); }
	void DaoWrap_timerEvent( QTimerEvent* _cp0 ){ QObject::timerEvent( _cp0 ); }
};
DaoCxx_QObject* DAO_DLL_QTCORE DaoCxx_QObject_New( QObject* parent );
DaoCxx_QObject* DAO_DLL_QTCORE DaoCxx_QObject_New( QObjectPrivate &dd, QObject* parent );


void DAO_DLL_QTCORE Dao_QAbstractAnimation_InitSS( QAbstractAnimation *p );
class DAO_DLL_QTCORE DaoSS_QAbstractAnimation :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QAbstractAnimation() : DaoSS_QObject() {}
public slots:
   void slot_start151( void*, void*, const DaoQtMessage& );
   void slot_pause555( void*, void*, const DaoQtMessage& );
   void slot_resume427( void*, void*, const DaoQtMessage& );
   void slot_setPaused773( void*, void*, const DaoQtMessage& );
   void slot_stop638( void*, void*, const DaoQtMessage& );
   void slot_setCurrentTime670( void*, void*, const DaoQtMessage& );
   void slot_finished719(  );
   void slot_stateChanged155( QAbstractAnimation::State newState, QAbstractAnimation::State oldState );
   void slot_currentLoopChanged94( int currentLoop );
   void slot_directionChanged551( QAbstractAnimation::Direction _cp0 );

signals:
   void signal_start151(QAbstractAnimation::DeletionPolicy);
   void signal_pause555();
   void signal_resume427();
   void signal_setPaused773(bool);
   void signal_stop638();
   void signal_setCurrentTime670(int);
   void signal_finished719(void*,const QString&,const DaoQtMessage&);
   void signal_stateChanged155(void*,const QString&,const DaoQtMessage&);
   void signal_currentLoopChanged94(void*,const QString&,const DaoQtMessage&);
   void signal_directionChanged551(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QAbstractAnimation  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QAbstractAnimation(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QAbstractAnimation *self, DaoCData *d );
	QAbstractAnimation *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	int duration( int &_cs  )const;
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	void updateCurrentTime( int &_cs, int currentTime );
	void updateDirection( int &_cs, QAbstractAnimation::Direction direction );
	void updateState( int &_cs, QAbstractAnimation::State newState, QAbstractAnimation::State oldState );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QAbstractAnimation : public QAbstractAnimation, public DaoCxxVirt_QAbstractAnimation
{ Q_OBJECT
	public:
   DaoCxx_QAbstractAnimation( QAbstractAnimationPrivate &dd, QObject* parent = 0 ) : QAbstractAnimation( dd, parent ){}
   DaoCxx_QAbstractAnimation( QObject* parent = 0 ) : QAbstractAnimation( parent ){}
	~DaoCxx_QAbstractAnimation();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	int duration(  )const;
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
	void updateCurrentTime( int currentTime );
	void updateDirection( QAbstractAnimation::Direction direction );
	void updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState );
	bool event( QEvent* event );
	bool DaoWrap_event( QEvent* event ){ return QAbstractAnimation::event( event ); }
	void DaoWrap_updateCurrentTime( int currentTime ){ QAbstractAnimation::updateCurrentTime( currentTime ); }
	void DaoWrap_updateDirection( QAbstractAnimation::Direction direction ){ QAbstractAnimation::updateDirection( direction ); }
	void DaoWrap_updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState ){ QAbstractAnimation::updateState( newState, oldState ); }
};
DaoCxx_QAbstractAnimation* DAO_DLL_QTCORE DaoCxx_QAbstractAnimation_New( QAbstractAnimationPrivate &dd, QObject* parent );
DaoCxx_QAbstractAnimation* DAO_DLL_QTCORE DaoCxx_QAbstractAnimation_New( QObject* parent );


void DAO_DLL_QTCORE Dao_QAbstractEventDispatcher_InitSS( QAbstractEventDispatcher *p );
class DAO_DLL_QTCORE DaoSS_QAbstractEventDispatcher :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QAbstractEventDispatcher() : DaoSS_QObject() {}
public slots:
   void slot_aboutToBlock941(  );
   void slot_awake617(  );

signals:
   void signal_aboutToBlock941(void*,const QString&,const DaoQtMessage&);
   void signal_awake617(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QAbstractEventDispatcher  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QAbstractEventDispatcher(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QAbstractEventDispatcher *self, DaoCData *d );
	QAbstractEventDispatcher *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void closingDown( int &_cs  );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void flush( int &_cs  );
	bool hasPendingEvents( int &_cs  );
	void interrupt( int &_cs  );
	bool processEvents( int &_cs, QEventLoop::ProcessEventsFlags flags );
	void registerSocketNotifier( int &_cs, QSocketNotifier* notifier );
	void registerTimer( int &_cs, int timerId, int interval, QObject* object );
	void startingUp( int &_cs  );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	void unregisterSocketNotifier( int &_cs, QSocketNotifier* notifier );
	bool unregisterTimer( int &_cs, int timerId );
	bool unregisterTimers( int &_cs, QObject* object );
	void wakeUp( int &_cs  );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QAbstractEventDispatcher : public QAbstractEventDispatcher, public DaoCxxVirt_QAbstractEventDispatcher
{ Q_OBJECT
	public:
   DaoCxx_QAbstractEventDispatcher( QAbstractEventDispatcherPrivate &_cp0, QObject* parent ) : QAbstractEventDispatcher( _cp0, parent ){}
   DaoCxx_QAbstractEventDispatcher( QObject* parent = 0 ) : QAbstractEventDispatcher( parent ){}
	~DaoCxx_QAbstractEventDispatcher();
	void DaoInitWrapper();
  QList<TimerInfo> registeredTimers(QObject*)const{/*XXX 1*/}
	void childEvent( QChildEvent* _cp0 );
	void closingDown(  );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void flush(  );
	bool hasPendingEvents(  );
	void interrupt(  );
	bool processEvents( QEventLoop::ProcessEventsFlags flags );
	void registerSocketNotifier( QSocketNotifier* notifier );
	void registerTimer( int timerId, int interval, QObject* object );
	void startingUp(  );
	void timerEvent( QTimerEvent* _cp0 );
	void unregisterSocketNotifier( QSocketNotifier* notifier );
	bool unregisterTimer( int timerId );
	bool unregisterTimers( QObject* object );
	void wakeUp(  );
};
DaoCxx_QAbstractEventDispatcher* DAO_DLL_QTCORE DaoCxx_QAbstractEventDispatcher_New( QAbstractEventDispatcherPrivate &_cp0, QObject* parent );
DaoCxx_QAbstractEventDispatcher* DAO_DLL_QTCORE DaoCxx_QAbstractEventDispatcher_New( QObject* parent );

class DAO_DLL_QTCORE DaoCxxVirt_QAbstractFileEngine 
{
	public:
	DaoCxxVirt_QAbstractFileEngine(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QAbstractFileEngine *self, DaoCData *d );
	QAbstractFileEngine *self;
	DaoCData *cdata;
	QAbstractFileEngine::Iterator* beginEntryList( int &_cs, QDir::Filters filters, const QStringList &filterNames );
	bool caseSensitive( int &_cs  )const;
	bool close( int &_cs  );
	bool copy( int &_cs, const QString &newName );
	QAbstractFileEngine::Iterator* endEntryList( int &_cs  );
	QStringList entryList( int &_cs, QDir::Filters filters, const QStringList &filterNames )const;
	bool extension( int &_cs, int extension, const QAbstractFileEngine::ExtensionOption* option, QAbstractFileEngine::ExtensionReturn* output );
	QAbstractFileEngine::FileFlags fileFlags( int &_cs, QAbstractFileEngine::FileFlags type )const;
	QString fileName( int &_cs, int file )const;
	QDateTime fileTime( int &_cs, int time )const;
	bool flush( int &_cs  );
	int handle( int &_cs  )const;
	bool isRelativePath( int &_cs  )const;
	bool isSequential( int &_cs  )const;
	bool link( int &_cs, const QString &newName );
	bool mkdir( int &_cs, const QString &dirName, bool createParentDirectories )const;
	bool open( int &_cs, QIODevice::OpenMode openMode );
	QString owner( int &_cs, int _cp0 )const;
	uint ownerId( int &_cs, int _cp0 )const;
	qint64 pos( int &_cs  )const;
	qint64 read( int &_cs, char* data, qint64 maxlen );
	qint64 readLine( int &_cs, char* data, qint64 maxlen );
	bool remove( int &_cs  );
	bool rename( int &_cs, const QString &newName );
	bool rmdir( int &_cs, const QString &dirName, bool recurseParentDirectories )const;
	bool seek( int &_cs, qint64 pos );
	void setFileName( int &_cs, const QString &file );
	bool setPermissions( int &_cs, uint perms );
	bool setSize( int &_cs, qint64 size );
	qint64 size( int &_cs  )const;
	bool supportsExtension( int &_cs, int extension )const;
	qint64 write( int &_cs, const char* data, qint64 len );

};
class DAO_DLL_QTCORE DaoCxx_QAbstractFileEngine : public QAbstractFileEngine, public DaoCxxVirt_QAbstractFileEngine
{ 
	public:
   DaoCxx_QAbstractFileEngine(  ) : QAbstractFileEngine(  ){}
   DaoCxx_QAbstractFileEngine( QAbstractFileEnginePrivate &_cp0 ) : QAbstractFileEngine( _cp0 ){}
	~DaoCxx_QAbstractFileEngine();
	void DaoInitWrapper();
	QAbstractFileEngine::Iterator* beginEntryList( QDir::Filters filters, const QStringList &filterNames );
	bool caseSensitive(  )const;
	bool close(  );
	bool copy( const QString &newName );
	QAbstractFileEngine::Iterator* endEntryList(  );
	QStringList entryList( QDir::Filters filters, const QStringList &filterNames )const;
	bool extension( QAbstractFileEngine::Extension extension, const QAbstractFileEngine::ExtensionOption* option = 0, QAbstractFileEngine::ExtensionReturn* output = 0 );
	QAbstractFileEngine::FileFlags fileFlags( QAbstractFileEngine::FileFlags type=FileInfoAll )const;
	QString fileName( QAbstractFileEngine::FileName file=DefaultName )const;
	QDateTime fileTime( QAbstractFileEngine::FileTime time )const;
	bool flush(  );
	int handle(  )const;
	bool isRelativePath(  )const;
	bool isSequential(  )const;
	bool link( const QString &newName );
	bool mkdir( const QString &dirName, bool createParentDirectories )const;
	bool open( QIODevice::OpenMode openMode );
	QString owner( QAbstractFileEngine::FileOwner _cp0 )const;
	uint ownerId( QAbstractFileEngine::FileOwner _cp0 )const;
	qint64 pos(  )const;
	qint64 read( char* data, qint64 maxlen );
	qint64 readLine( char* data, qint64 maxlen );
	bool remove(  );
	bool rename( const QString &newName );
	bool rmdir( const QString &dirName, bool recurseParentDirectories )const;
	bool seek( qint64 pos );
	void setFileName( const QString &file );
	bool setPermissions( uint perms );
	bool setSize( qint64 size );
	qint64 size(  )const;
	bool supportsExtension( QAbstractFileEngine::Extension extension )const;
	qint64 write( const char* data, qint64 len );
	void DaoWrap_setError( QFile::FileError error, const QString &str ){ QAbstractFileEngine::setError( error, str ); }
};
DaoCxx_QAbstractFileEngine* DAO_DLL_QTCORE DaoCxx_QAbstractFileEngine_New(  );
DaoCxx_QAbstractFileEngine* DAO_DLL_QTCORE DaoCxx_QAbstractFileEngine_New( QAbstractFileEnginePrivate &_cp0 );

class DAO_DLL_QTCORE DaoCxxVirt_QAbstractFileEngineHandler 
{
	public:
	DaoCxxVirt_QAbstractFileEngineHandler(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QAbstractFileEngineHandler *self, DaoCData *d );
	QAbstractFileEngineHandler *self;
	DaoCData *cdata;
	QAbstractFileEngine* create( int &_cs, const QString &fileName )const;

};
class DAO_DLL_QTCORE DaoCxx_QAbstractFileEngineHandler : public QAbstractFileEngineHandler, public DaoCxxVirt_QAbstractFileEngineHandler
{ 
	public:
   DaoCxx_QAbstractFileEngineHandler(  ) : QAbstractFileEngineHandler(  ){}
	~DaoCxx_QAbstractFileEngineHandler();
	void DaoInitWrapper();
	QAbstractFileEngine* create( const QString &fileName )const;
};
DaoCxx_QAbstractFileEngineHandler* DAO_DLL_QTCORE DaoCxx_QAbstractFileEngineHandler_New(  );

class DAO_DLL_QTCORE DaoCxxVirt_QAbstractFileEngineIterator 
{
	public:
	DaoCxxVirt_QAbstractFileEngineIterator(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QAbstractFileEngineIterator *self, DaoCData *d );
	QAbstractFileEngineIterator *self;
	DaoCData *cdata;
	QFileInfo currentFileInfo( int &_cs  )const;
	QString currentFileName( int &_cs  )const;
	QVariant entryInfo( int &_cs, int type )const;
	bool hasNext( int &_cs  )const;
	QString next( int &_cs  );

};
class DAO_DLL_QTCORE DaoCxx_QAbstractFileEngineIterator : public QAbstractFileEngineIterator, public DaoCxxVirt_QAbstractFileEngineIterator
{ 
	public:
   DaoCxx_QAbstractFileEngineIterator( QDir::Filters filters, const QStringList &nameFilters ) : QAbstractFileEngineIterator( filters, nameFilters ){}
	~DaoCxx_QAbstractFileEngineIterator();
	void DaoInitWrapper();
	QFileInfo currentFileInfo(  )const;
	QString currentFileName(  )const;
	QVariant entryInfo( QAbstractFileEngineIterator::EntryInfoType type )const;
	bool hasNext(  )const;
	QString next(  );
	QVariant DaoWrap_entryInfo( QAbstractFileEngineIterator::EntryInfoType type )const{ return QAbstractFileEngineIterator::entryInfo( type ); }
};
DaoCxx_QAbstractFileEngineIterator* DAO_DLL_QTCORE DaoCxx_QAbstractFileEngineIterator_New( QDir::Filters filters, const QStringList &nameFilters );


void DAO_DLL_QTCORE Dao_QAbstractItemModel_InitSS( QAbstractItemModel *p );
class DAO_DLL_QTCORE DaoSS_QAbstractItemModel :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QAbstractItemModel() : DaoSS_QObject() {}
public slots:
   void slot_submit61( void*, void*, const DaoQtMessage& );
   void slot_revert861( void*, void*, const DaoQtMessage& );
   void slot_dataChanged850( const QModelIndex &topLeft, const QModelIndex &bottomRight );
   void slot_headerDataChanged190( Qt::Orientation orientation, int first, int last );
   void slot_layoutChanged952(  );
   void slot_layoutAboutToBeChanged228(  );
   void slot_rowsAboutToBeInserted302( const QModelIndex &parent, int first, int last );
   void slot_rowsInserted487( const QModelIndex &parent, int first, int last );
   void slot_rowsAboutToBeRemoved669( const QModelIndex &parent, int first, int last );
   void slot_rowsRemoved391( const QModelIndex &parent, int first, int last );
   void slot_columnsAboutToBeInserted346( const QModelIndex &parent, int first, int last );
   void slot_columnsInserted211( const QModelIndex &parent, int first, int last );
   void slot_columnsAboutToBeRemoved713( const QModelIndex &parent, int first, int last );
   void slot_columnsRemoved489( const QModelIndex &parent, int first, int last );
   void slot_modelAboutToBeReset591(  );
   void slot_modelReset619(  );
   void slot_rowsAboutToBeMoved711( const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationRow );
   void slot_rowsMoved503( const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row );
   void slot_columnsAboutToBeMoved897( const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationColumn );
   void slot_columnsMoved337( const QModelIndex &parent, int start, int end, const QModelIndex &destination, int column );

signals:
   void signal_submit61();
   void signal_revert861();
   void signal_dataChanged850(void*,const QString&,const DaoQtMessage&);
   void signal_headerDataChanged190(void*,const QString&,const DaoQtMessage&);
   void signal_layoutChanged952(void*,const QString&,const DaoQtMessage&);
   void signal_layoutAboutToBeChanged228(void*,const QString&,const DaoQtMessage&);
   void signal_rowsAboutToBeInserted302(void*,const QString&,const DaoQtMessage&);
   void signal_rowsInserted487(void*,const QString&,const DaoQtMessage&);
   void signal_rowsAboutToBeRemoved669(void*,const QString&,const DaoQtMessage&);
   void signal_rowsRemoved391(void*,const QString&,const DaoQtMessage&);
   void signal_columnsAboutToBeInserted346(void*,const QString&,const DaoQtMessage&);
   void signal_columnsInserted211(void*,const QString&,const DaoQtMessage&);
   void signal_columnsAboutToBeRemoved713(void*,const QString&,const DaoQtMessage&);
   void signal_columnsRemoved489(void*,const QString&,const DaoQtMessage&);
   void signal_modelAboutToBeReset591(void*,const QString&,const DaoQtMessage&);
   void signal_modelReset619(void*,const QString&,const DaoQtMessage&);
   void signal_rowsAboutToBeMoved711(void*,const QString&,const DaoQtMessage&);
   void signal_rowsMoved503(void*,const QString&,const DaoQtMessage&);
   void signal_columnsAboutToBeMoved897(void*,const QString&,const DaoQtMessage&);
   void signal_columnsMoved337(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QAbstractItemModel  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QAbstractItemModel(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QAbstractItemModel *self, DaoCData *d );
	QAbstractItemModel *self;
	DaoCData *cdata;
	QModelIndex buddy( int &_cs, const QModelIndex &index )const;
	bool canFetchMore( int &_cs, const QModelIndex &parent )const;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	int columnCount( int &_cs, const QModelIndex &parent )const;
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	QVariant data( int &_cs, const QModelIndex &index, int role )const;
	void disconnectNotify( int &_cs, const char* signal );
	bool dropMimeData( int &_cs, const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex &parent );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void fetchMore( int &_cs, const QModelIndex &parent );
	Qt::ItemFlags flags( int &_cs, const QModelIndex &index )const;
	bool hasChildren( int &_cs, const QModelIndex &parent )const;
	QVariant headerData( int &_cs, int section, Qt::Orientation orientation, int role )const;
	QModelIndex index( int &_cs, int row, int column, const QModelIndex &parent )const;
	bool insertColumns( int &_cs, int column, int count, const QModelIndex &parent );
	bool insertRows( int &_cs, int row, int count, const QModelIndex &parent );
	QModelIndexList match( int &_cs, const QModelIndex &start, int role, const QVariant &value, int hits, Qt::MatchFlags flags )const;
	QMimeData* mimeData( int &_cs, const QModelIndexList &indexes )const;
	QStringList mimeTypes( int &_cs  )const;
	QModelIndex parent( int &_cs, const QModelIndex &child )const;
	bool removeColumns( int &_cs, int column, int count, const QModelIndex &parent );
	bool removeRows( int &_cs, int row, int count, const QModelIndex &parent );
	void revert( int &_cs  );
	int rowCount( int &_cs, const QModelIndex &parent )const;
	bool setData( int &_cs, const QModelIndex &index, const QVariant &value, int role );
	bool setHeaderData( int &_cs, int section, Qt::Orientation orientation, const QVariant &value, int role );
	void sort( int &_cs, int column, Qt::SortOrder order );
	QSize span( int &_cs, const QModelIndex &index )const;
	bool submit( int &_cs  );
	Qt::DropActions supportedDropActions( int &_cs  )const;
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QAbstractItemModel : public QAbstractItemModel, public DaoCxxVirt_QAbstractItemModel
{ Q_OBJECT
	public:
   DaoCxx_QAbstractItemModel( QAbstractItemModelPrivate &dd, QObject* parent = 0 ) : QAbstractItemModel( dd, parent ){}
   DaoCxx_QAbstractItemModel( QObject* parent = 0 ) : QAbstractItemModel( parent ){}
	~DaoCxx_QAbstractItemModel();
	void DaoInitWrapper();
	QModelIndex buddy( const QModelIndex &index )const;
	bool canFetchMore( const QModelIndex &parent )const;
	void childEvent( QChildEvent* _cp0 );
	int columnCount( const QModelIndex &parent = QModelIndex() )const;
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	QVariant data( const QModelIndex &index, int role = Qt::DisplayRole )const;
	void disconnectNotify( const char* signal );
	bool dropMimeData( const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex &parent );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void fetchMore( const QModelIndex &parent );
	Qt::ItemFlags flags( const QModelIndex &index )const;
	bool hasChildren( const QModelIndex &parent = QModelIndex() )const;
	QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole )const;
	QModelIndex index( int row, int column, const QModelIndex &parent = QModelIndex() )const;
	bool insertColumns( int column, int count, const QModelIndex &parent = QModelIndex() );
	bool insertRows( int row, int count, const QModelIndex &parent = QModelIndex() );
	QModelIndexList match( const QModelIndex &start, int role, const QVariant &value, int hits = 1, Qt::MatchFlags flags = Qt::MatchFlags(Qt::MatchStartsWith|Qt::MatchWrap) )const;
	QMimeData* mimeData( const QModelIndexList &indexes )const;
	QStringList mimeTypes(  )const;
	QModelIndex parent( const QModelIndex &child )const;
	bool removeColumns( int column, int count, const QModelIndex &parent = QModelIndex() );
	bool removeRows( int row, int count, const QModelIndex &parent = QModelIndex() );
	void revert(  );
	int rowCount( const QModelIndex &parent = QModelIndex() )const;
	bool setData( const QModelIndex &index, const QVariant &value, int role = Qt::EditRole );
	bool setHeaderData( int section, Qt::Orientation orientation, const QVariant &value, int role = Qt::EditRole );
	void sort( int column, Qt::SortOrder order = Qt::AscendingOrder );
	QSize span( const QModelIndex &index )const;
	bool submit(  );
	Qt::DropActions supportedDropActions(  )const;
	void timerEvent( QTimerEvent* _cp0 );
	void DaoWrap_beginInsertColumns( const QModelIndex &parent, int first, int last ){ QAbstractItemModel::beginInsertColumns( parent, first, last ); }
	void DaoWrap_beginInsertRows( const QModelIndex &parent, int first, int last ){ QAbstractItemModel::beginInsertRows( parent, first, last ); }
	bool DaoWrap_beginMoveColumns( const QModelIndex &sourceParent, int sourceFirst, int sourceLast, const QModelIndex &destinationParent, int destinationColumn ){ return QAbstractItemModel::beginMoveColumns( sourceParent, sourceFirst, sourceLast, destinationParent, destinationColumn ); }
	bool DaoWrap_beginMoveRows( const QModelIndex &sourceParent, int sourceFirst, int sourceLast, const QModelIndex &destinationParent, int destinationRow ){ return QAbstractItemModel::beginMoveRows( sourceParent, sourceFirst, sourceLast, destinationParent, destinationRow ); }
	void DaoWrap_beginRemoveColumns( const QModelIndex &parent, int first, int last ){ QAbstractItemModel::beginRemoveColumns( parent, first, last ); }
	void DaoWrap_beginRemoveRows( const QModelIndex &parent, int first, int last ){ QAbstractItemModel::beginRemoveRows( parent, first, last ); }
	void DaoWrap_beginResetModel(  ){ QAbstractItemModel::beginResetModel(  ); }
	void DaoWrap_changePersistentIndex( const QModelIndex &from, const QModelIndex &to ){ QAbstractItemModel::changePersistentIndex( from, to ); }
	void DaoWrap_changePersistentIndexList( const QModelIndexList &from, const QModelIndexList &to ){ QAbstractItemModel::changePersistentIndexList( from, to ); }
	QModelIndex DaoWrap_createIndex( int row, int column, int id )const{ return QAbstractItemModel::createIndex( row, column, id ); }
	QModelIndex DaoWrap_createIndex( int row, int column, quint32 id )const{ return QAbstractItemModel::createIndex( row, column, id ); }
	QModelIndex DaoWrap_createIndex( int row, int column, void* data = 0 )const{ return QAbstractItemModel::createIndex( row, column, data ); }
	bool DaoWrap_decodeData( int row, int column, const QModelIndex &parent, QDataStream &stream ){ return QAbstractItemModel::decodeData( row, column, parent, stream ); }
	void DaoWrap_encodeData( const QModelIndexList &indexes, QDataStream &stream )const{ QAbstractItemModel::encodeData( indexes, stream ); }
	void DaoWrap_endInsertColumns(  ){ QAbstractItemModel::endInsertColumns(  ); }
	void DaoWrap_endInsertRows(  ){ QAbstractItemModel::endInsertRows(  ); }
	void DaoWrap_endMoveColumns(  ){ QAbstractItemModel::endMoveColumns(  ); }
	void DaoWrap_endMoveRows(  ){ QAbstractItemModel::endMoveRows(  ); }
	void DaoWrap_endRemoveColumns(  ){ QAbstractItemModel::endRemoveColumns(  ); }
	void DaoWrap_endRemoveRows(  ){ QAbstractItemModel::endRemoveRows(  ); }
	void DaoWrap_endResetModel(  ){ QAbstractItemModel::endResetModel(  ); }
	QModelIndexList DaoWrap_persistentIndexList(  )const{ return QAbstractItemModel::persistentIndexList(  ); }
	void DaoWrap_reset(  ){ QAbstractItemModel::reset(  ); }
};
DaoCxx_QAbstractItemModel* DAO_DLL_QTCORE DaoCxx_QAbstractItemModel_New( QAbstractItemModelPrivate &dd, QObject* parent );
DaoCxx_QAbstractItemModel* DAO_DLL_QTCORE DaoCxx_QAbstractItemModel_New( QObject* parent );


void DAO_DLL_QTCORE Dao_QAbstractListModel_InitSS( QAbstractListModel *p );
class DAO_DLL_QTCORE DaoSS_QAbstractListModel :  public DaoSS_QAbstractItemModel
{ Q_OBJECT
public:
	DaoSS_QAbstractListModel() : DaoSS_QAbstractItemModel() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QAbstractListModel  : public DaoCxxVirt_QAbstractItemModel
{
	public:
	DaoCxxVirt_QAbstractListModel(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QAbstractListModel *self, DaoCData *d );
	QAbstractListModel *self;
	DaoCData *cdata;
	QModelIndex buddy( int &_cs, const QModelIndex &index )const;
	bool canFetchMore( int &_cs, const QModelIndex &parent )const;
	QVariant data( int &_cs, const QModelIndex &index, int role )const;
	void fetchMore( int &_cs, const QModelIndex &parent );
	Qt::ItemFlags flags( int &_cs, const QModelIndex &index )const;
	QVariant headerData( int &_cs, int section, Qt::Orientation orientation, int role )const;
	bool insertColumns( int &_cs, int column, int count, const QModelIndex &parent );
	bool insertRows( int &_cs, int row, int count, const QModelIndex &parent );
	QModelIndexList match( int &_cs, const QModelIndex &start, int role, const QVariant &value, int hits, Qt::MatchFlags flags )const;
	QMimeData* mimeData( int &_cs, const QModelIndexList &indexes )const;
	QStringList mimeTypes( int &_cs  )const;
	bool removeColumns( int &_cs, int column, int count, const QModelIndex &parent );
	bool removeRows( int &_cs, int row, int count, const QModelIndex &parent );
	void revert( int &_cs  );
	int rowCount( int &_cs, const QModelIndex &parent )const;
	bool setData( int &_cs, const QModelIndex &index, const QVariant &value, int role );
	bool setHeaderData( int &_cs, int section, Qt::Orientation orientation, const QVariant &value, int role );
	void sort( int &_cs, int column, Qt::SortOrder order );
	QSize span( int &_cs, const QModelIndex &index )const;
	bool submit( int &_cs  );
	Qt::DropActions supportedDropActions( int &_cs  )const;
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QAbstractListModel : public QAbstractListModel, public DaoCxxVirt_QAbstractListModel
{ Q_OBJECT
	public:
   DaoCxx_QAbstractListModel( QAbstractItemModelPrivate &dd, QObject* parent ) : QAbstractListModel( dd, parent ){}
   DaoCxx_QAbstractListModel( QObject* parent = 0 ) : QAbstractListModel( parent ){}
	~DaoCxx_QAbstractListModel();
	void DaoInitWrapper();
	QModelIndex buddy( const QModelIndex &index )const;
	bool canFetchMore( const QModelIndex &parent )const;
	QVariant data( const QModelIndex &index, int role = Qt::DisplayRole )const;
	void fetchMore( const QModelIndex &parent );
	Qt::ItemFlags flags( const QModelIndex &index )const;
	QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole )const;
	bool insertColumns( int column, int count, const QModelIndex &parent = QModelIndex() );
	bool insertRows( int row, int count, const QModelIndex &parent = QModelIndex() );
	QModelIndexList match( const QModelIndex &start, int role, const QVariant &value, int hits = 1, Qt::MatchFlags flags = Qt::MatchFlags(Qt::MatchStartsWith|Qt::MatchWrap) )const;
	QMimeData* mimeData( const QModelIndexList &indexes )const;
	QStringList mimeTypes(  )const;
	bool removeColumns( int column, int count, const QModelIndex &parent = QModelIndex() );
	bool removeRows( int row, int count, const QModelIndex &parent = QModelIndex() );
	void revert(  );
	int rowCount( const QModelIndex &parent = QModelIndex() )const;
	bool setData( const QModelIndex &index, const QVariant &value, int role = Qt::EditRole );
	bool setHeaderData( int section, Qt::Orientation orientation, const QVariant &value, int role = Qt::EditRole );
	void sort( int column, Qt::SortOrder order = Qt::AscendingOrder );
	QSize span( const QModelIndex &index )const;
	bool submit(  );
	Qt::DropActions supportedDropActions(  )const;
	bool dropMimeData( const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex &parent );
	QModelIndex index( int row, int column, const QModelIndex &parent )const;
};
DaoCxx_QAbstractListModel* DAO_DLL_QTCORE DaoCxx_QAbstractListModel_New( QAbstractItemModelPrivate &dd, QObject* parent );
DaoCxx_QAbstractListModel* DAO_DLL_QTCORE DaoCxx_QAbstractListModel_New( QObject* parent );


void DAO_DLL_QTCORE Dao_QAbstractState_InitSS( QAbstractState *p );
class DAO_DLL_QTCORE DaoSS_QAbstractState :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QAbstractState() : DaoSS_QObject() {}
public slots:
   void slot_entered63(  );
   void slot_exited900(  );

signals:
   void signal_entered63(void*,const QString&,const DaoQtMessage&);
   void signal_exited900(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QAbstractState  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QAbstractState(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QAbstractState *self, DaoCData *d );
	QAbstractState *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void onEntry( int &_cs, QEvent* event );
	void onExit( int &_cs, QEvent* event );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QAbstractState : public QAbstractState, public DaoCxxVirt_QAbstractState
{ Q_OBJECT
	public:
   DaoCxx_QAbstractState( QAbstractStatePrivate &dd, QState* parent ) : QAbstractState( dd, parent ){}
   DaoCxx_QAbstractState( QState* parent = 0 ) : QAbstractState( parent ){}
	~DaoCxx_QAbstractState();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void onEntry( QEvent* event );
	void onExit( QEvent* event );
	void timerEvent( QTimerEvent* _cp0 );
	bool event( QEvent* e );
	bool DaoWrap_event( QEvent* e ){ return QAbstractState::event( e ); }
	void DaoWrap_onEntry( QEvent* event ){ QAbstractState::onEntry( event ); }
	void DaoWrap_onExit( QEvent* event ){ QAbstractState::onExit( event ); }
};
DaoCxx_QAbstractState* DAO_DLL_QTCORE DaoCxx_QAbstractState_New( QAbstractStatePrivate &dd, QState* parent );
DaoCxx_QAbstractState* DAO_DLL_QTCORE DaoCxx_QAbstractState_New( QState* parent );


void DAO_DLL_QTCORE Dao_QAbstractTableModel_InitSS( QAbstractTableModel *p );
class DAO_DLL_QTCORE DaoSS_QAbstractTableModel :  public DaoSS_QAbstractItemModel
{ Q_OBJECT
public:
	DaoSS_QAbstractTableModel() : DaoSS_QAbstractItemModel() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QAbstractTableModel  : public DaoCxxVirt_QAbstractItemModel
{
	public:
	DaoCxxVirt_QAbstractTableModel(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QAbstractTableModel *self, DaoCData *d );
	QAbstractTableModel *self;
	DaoCData *cdata;
	QModelIndex buddy( int &_cs, const QModelIndex &index )const;
	bool canFetchMore( int &_cs, const QModelIndex &parent )const;
	int columnCount( int &_cs, const QModelIndex &parent )const;
	QVariant data( int &_cs, const QModelIndex &index, int role )const;
	void fetchMore( int &_cs, const QModelIndex &parent );
	Qt::ItemFlags flags( int &_cs, const QModelIndex &index )const;
	QVariant headerData( int &_cs, int section, Qt::Orientation orientation, int role )const;
	bool insertColumns( int &_cs, int column, int count, const QModelIndex &parent );
	bool insertRows( int &_cs, int row, int count, const QModelIndex &parent );
	QModelIndexList match( int &_cs, const QModelIndex &start, int role, const QVariant &value, int hits, Qt::MatchFlags flags )const;
	QMimeData* mimeData( int &_cs, const QModelIndexList &indexes )const;
	QStringList mimeTypes( int &_cs  )const;
	bool removeColumns( int &_cs, int column, int count, const QModelIndex &parent );
	bool removeRows( int &_cs, int row, int count, const QModelIndex &parent );
	void revert( int &_cs  );
	int rowCount( int &_cs, const QModelIndex &parent )const;
	bool setData( int &_cs, const QModelIndex &index, const QVariant &value, int role );
	bool setHeaderData( int &_cs, int section, Qt::Orientation orientation, const QVariant &value, int role );
	void sort( int &_cs, int column, Qt::SortOrder order );
	QSize span( int &_cs, const QModelIndex &index )const;
	bool submit( int &_cs  );
	Qt::DropActions supportedDropActions( int &_cs  )const;
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QAbstractTableModel : public QAbstractTableModel, public DaoCxxVirt_QAbstractTableModel
{ Q_OBJECT
	public:
   DaoCxx_QAbstractTableModel( QAbstractItemModelPrivate &dd, QObject* parent ) : QAbstractTableModel( dd, parent ){}
   DaoCxx_QAbstractTableModel( QObject* parent = 0 ) : QAbstractTableModel( parent ){}
	~DaoCxx_QAbstractTableModel();
	void DaoInitWrapper();
	QModelIndex buddy( const QModelIndex &index )const;
	bool canFetchMore( const QModelIndex &parent )const;
	int columnCount( const QModelIndex &parent = QModelIndex() )const;
	QVariant data( const QModelIndex &index, int role = Qt::DisplayRole )const;
	void fetchMore( const QModelIndex &parent );
	Qt::ItemFlags flags( const QModelIndex &index )const;
	QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole )const;
	bool insertColumns( int column, int count, const QModelIndex &parent = QModelIndex() );
	bool insertRows( int row, int count, const QModelIndex &parent = QModelIndex() );
	QModelIndexList match( const QModelIndex &start, int role, const QVariant &value, int hits = 1, Qt::MatchFlags flags = Qt::MatchFlags(Qt::MatchStartsWith|Qt::MatchWrap) )const;
	QMimeData* mimeData( const QModelIndexList &indexes )const;
	QStringList mimeTypes(  )const;
	bool removeColumns( int column, int count, const QModelIndex &parent = QModelIndex() );
	bool removeRows( int row, int count, const QModelIndex &parent = QModelIndex() );
	void revert(  );
	int rowCount( const QModelIndex &parent = QModelIndex() )const;
	bool setData( const QModelIndex &index, const QVariant &value, int role = Qt::EditRole );
	bool setHeaderData( int section, Qt::Orientation orientation, const QVariant &value, int role = Qt::EditRole );
	void sort( int column, Qt::SortOrder order = Qt::AscendingOrder );
	QSize span( const QModelIndex &index )const;
	bool submit(  );
	Qt::DropActions supportedDropActions(  )const;
	bool dropMimeData( const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex &parent );
	QModelIndex index( int row, int column, const QModelIndex &parent )const;
};
DaoCxx_QAbstractTableModel* DAO_DLL_QTCORE DaoCxx_QAbstractTableModel_New( QAbstractItemModelPrivate &dd, QObject* parent );
DaoCxx_QAbstractTableModel* DAO_DLL_QTCORE DaoCxx_QAbstractTableModel_New( QObject* parent );


void DAO_DLL_QTCORE Dao_QAbstractTransition_InitSS( QAbstractTransition *p );
class DAO_DLL_QTCORE DaoSS_QAbstractTransition :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QAbstractTransition() : DaoSS_QObject() {}
public slots:
   void slot_triggered559(  );

signals:
   void signal_triggered559(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QAbstractTransition  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QAbstractTransition(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QAbstractTransition *self, DaoCData *d );
	QAbstractTransition *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	bool eventTest( int &_cs, QEvent* event );
	void onTransition( int &_cs, QEvent* event );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QAbstractTransition : public QAbstractTransition, public DaoCxxVirt_QAbstractTransition
{ Q_OBJECT
	public:
   DaoCxx_QAbstractTransition( QAbstractTransitionPrivate &dd, QState* parent ) : QAbstractTransition( dd, parent ){}
   DaoCxx_QAbstractTransition( QState* sourceState = 0 ) : QAbstractTransition( sourceState ){}
	~DaoCxx_QAbstractTransition();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	bool eventTest( QEvent* event );
	void onTransition( QEvent* event );
	void timerEvent( QTimerEvent* _cp0 );
	bool event( QEvent* e );
	bool DaoWrap_event( QEvent* e ){ return QAbstractTransition::event( e ); }
	bool DaoWrap_eventTest( QEvent* event ){ return QAbstractTransition::eventTest( event ); }
	void DaoWrap_onTransition( QEvent* event ){ QAbstractTransition::onTransition( event ); }
};
DaoCxx_QAbstractTransition* DAO_DLL_QTCORE DaoCxx_QAbstractTransition_New( QAbstractTransitionPrivate &dd, QState* parent );
DaoCxx_QAbstractTransition* DAO_DLL_QTCORE DaoCxx_QAbstractTransition_New( QState* sourceState );


void DAO_DLL_QTCORE Dao_QAnimationGroup_InitSS( QAnimationGroup *p );
class DAO_DLL_QTCORE DaoSS_QAnimationGroup :  public DaoSS_QAbstractAnimation
{ Q_OBJECT
public:
	DaoSS_QAnimationGroup() : DaoSS_QAbstractAnimation() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QAnimationGroup  : public DaoCxxVirt_QAbstractAnimation
{
	public:
	DaoCxxVirt_QAnimationGroup(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QAnimationGroup *self, DaoCData *d );
	QAnimationGroup *self;
	DaoCData *cdata;
	int duration( int &_cs  )const;
	void updateCurrentTime( int &_cs, int currentTime );
	void updateDirection( int &_cs, QAbstractAnimation::Direction direction );
	void updateState( int &_cs, QAbstractAnimation::State newState, QAbstractAnimation::State oldState );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QAnimationGroup : public QAnimationGroup, public DaoCxxVirt_QAnimationGroup
{ Q_OBJECT
	public:
   DaoCxx_QAnimationGroup( QAnimationGroupPrivate &dd, QObject* parent ) : QAnimationGroup( dd, parent ){}
   DaoCxx_QAnimationGroup( QObject* parent = 0 ) : QAnimationGroup( parent ){}
	~DaoCxx_QAnimationGroup();
	void DaoInitWrapper();
	int duration(  )const;
	void updateCurrentTime( int currentTime );
	void updateDirection( QAbstractAnimation::Direction direction );
	void updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState );
	bool event( QEvent* event );
	bool DaoWrap_event( QEvent* event ){ return QAnimationGroup::event( event ); }
};
DaoCxx_QAnimationGroup* DAO_DLL_QTCORE DaoCxx_QAnimationGroup_New( QAnimationGroupPrivate &dd, QObject* parent );
DaoCxx_QAnimationGroup* DAO_DLL_QTCORE DaoCxx_QAnimationGroup_New( QObject* parent );

QBasicAtomicInt* DAO_DLL_QTCORE Dao_QBasicAtomicInt_New();


QAtomicInt* DAO_DLL_QTCORE Dao_QAtomicInt_New( const QAtomicInt &other );
QAtomicInt* DAO_DLL_QTCORE Dao_QAtomicInt_New( int value );


QBasicTimer* DAO_DLL_QTCORE Dao_QBasicTimer_New(  );


QBitArray* DAO_DLL_QTCORE Dao_QBitArray_New(  );
QBitArray* DAO_DLL_QTCORE Dao_QBitArray_New( const QBitArray &other );
QBitArray* DAO_DLL_QTCORE Dao_QBitArray_New( int size, bool val );


void DAO_DLL_QTCORE Dao_QIODevice_InitSS( QIODevice *p );
class DAO_DLL_QTCORE DaoSS_QIODevice :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QIODevice() : DaoSS_QObject() {}
public slots:
   void slot_readyRead67(  );
   void slot_bytesWritten414( qint64 bytes );
   void slot_aboutToClose368(  );
   void slot_readChannelFinished907(  );

signals:
   void signal_readyRead67(void*,const QString&,const DaoQtMessage&);
   void signal_bytesWritten414(void*,const QString&,const DaoQtMessage&);
   void signal_aboutToClose368(void*,const QString&,const DaoQtMessage&);
   void signal_readChannelFinished907(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QIODevice  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QIODevice(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QIODevice *self, DaoCData *d );
	QIODevice *self;
	DaoCData *cdata;
	bool atEnd( int &_cs  )const;
	qint64 bytesAvailable( int &_cs  )const;
	qint64 bytesToWrite( int &_cs  )const;
	bool canReadLine( int &_cs  )const;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void close( int &_cs  );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	bool isSequential( int &_cs  )const;
	bool open( int &_cs, QIODevice::OpenMode mode );
	qint64 pos( int &_cs  )const;
	qint64 readData( int &_cs, char* data, qint64 maxlen );
	qint64 readLineData( int &_cs, char* data, qint64 maxlen );
	bool reset( int &_cs  );
	bool seek( int &_cs, qint64 pos );
	qint64 size( int &_cs  )const;
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	bool waitForBytesWritten( int &_cs, int msecs );
	bool waitForReadyRead( int &_cs, int msecs );
	qint64 writeData( int &_cs, const char* data, qint64 len );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QIODevice : public QIODevice, public DaoCxxVirt_QIODevice
{ Q_OBJECT
	public:
   DaoCxx_QIODevice(  ) : QIODevice(  ){}
   DaoCxx_QIODevice( QIODevicePrivate &dd, QObject* parent = 0 ) : QIODevice( dd, parent ){}
   DaoCxx_QIODevice( QObject* parent ) : QIODevice( parent ){}
	~DaoCxx_QIODevice();
	void DaoInitWrapper();
	bool atEnd(  )const;
	qint64 bytesAvailable(  )const;
	qint64 bytesToWrite(  )const;
	bool canReadLine(  )const;
	void childEvent( QChildEvent* _cp0 );
	void close(  );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	bool isSequential(  )const;
	bool open( QIODevice::OpenMode mode );
	qint64 pos(  )const;
	qint64 readData( char* data, qint64 maxlen );
	qint64 readLineData( char* data, qint64 maxlen );
	bool reset(  );
	bool seek( qint64 pos );
	qint64 size(  )const;
	void timerEvent( QTimerEvent* _cp0 );
	bool waitForBytesWritten( int msecs );
	bool waitForReadyRead( int msecs );
	qint64 writeData( const char* data, qint64 len );
	qint64 DaoWrap_readData( char* data, qint64 maxlen ){ return QIODevice::readData( data, maxlen ); }
	qint64 DaoWrap_readLineData( char* data, qint64 maxlen ){ return QIODevice::readLineData( data, maxlen ); }
	void DaoWrap_setErrorString( const QString &errorString ){ QIODevice::setErrorString( errorString ); }
	void DaoWrap_setOpenMode( QIODevice::OpenMode openMode ){ QIODevice::setOpenMode( openMode ); }
	qint64 DaoWrap_writeData( const char* data, qint64 len ){ return QIODevice::writeData( data, len ); }
};
DaoCxx_QIODevice* DAO_DLL_QTCORE DaoCxx_QIODevice_New(  );
DaoCxx_QIODevice* DAO_DLL_QTCORE DaoCxx_QIODevice_New( QIODevicePrivate &dd, QObject* parent );
DaoCxx_QIODevice* DAO_DLL_QTCORE DaoCxx_QIODevice_New( QObject* parent );


void DAO_DLL_QTCORE Dao_QBuffer_InitSS( QBuffer *p );
class DAO_DLL_QTCORE DaoSS_QBuffer :  public DaoSS_QIODevice
{ Q_OBJECT
public:
	DaoSS_QBuffer() : DaoSS_QIODevice() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QBuffer  : public DaoCxxVirt_QIODevice
{
	public:
	DaoCxxVirt_QBuffer(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QBuffer *self, DaoCData *d );
	QBuffer *self;
	DaoCData *cdata;
	qint64 bytesAvailable( int &_cs  )const;
	qint64 bytesToWrite( int &_cs  )const;
	bool isSequential( int &_cs  )const;
	bool open( int &_cs, QIODevice::OpenMode mode );
	qint64 readLineData( int &_cs, char* data, qint64 maxlen );
	bool reset( int &_cs  );
	bool waitForBytesWritten( int &_cs, int msecs );
	bool waitForReadyRead( int &_cs, int msecs );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QBuffer : public QBuffer, public DaoCxxVirt_QBuffer
{ Q_OBJECT
	public:
   DaoCxx_QBuffer( QByteArray* buf, QObject* parent = 0 ) : QBuffer( buf, parent ){}
   DaoCxx_QBuffer( QObject* parent = 0 ) : QBuffer( parent ){}
	~DaoCxx_QBuffer();
	void DaoInitWrapper();
	qint64 bytesAvailable(  )const;
	qint64 bytesToWrite(  )const;
	bool isSequential(  )const;
	bool open( QIODevice::OpenMode mode );
	qint64 readLineData( char* data, qint64 maxlen );
	bool reset(  );
	bool waitForBytesWritten( int msecs );
	bool waitForReadyRead( int msecs );
	bool atEnd(  )const;
	bool canReadLine(  )const;
	void close(  );
	void connectNotify( const char* _cp0 );
	void DaoWrap_connectNotify( const char* _cp0 ){ QBuffer::connectNotify( _cp0 ); }
	void disconnectNotify( const char* _cp0 );
	void DaoWrap_disconnectNotify( const char* _cp0 ){ QBuffer::disconnectNotify( _cp0 ); }
	qint64 pos(  )const;
	qint64 readData( char* data, qint64 maxlen );
	qint64 DaoWrap_readData( char* data, qint64 maxlen ){ return QBuffer::readData( data, maxlen ); }
	bool seek( qint64 off );
	qint64 size(  )const;
	qint64 writeData( const char* data, qint64 len );
	qint64 DaoWrap_writeData( const char* data, qint64 len ){ return QBuffer::writeData( data, len ); }
};
DaoCxx_QBuffer* DAO_DLL_QTCORE DaoCxx_QBuffer_New( QByteArray* buf, QObject* parent );
DaoCxx_QBuffer* DAO_DLL_QTCORE DaoCxx_QBuffer_New( QObject* parent );


QByteArray* DAO_DLL_QTCORE Dao_QByteArray_New(  );
QByteArray* DAO_DLL_QTCORE Dao_QByteArray_New( const QByteArray &_cp0 );
QByteArray* DAO_DLL_QTCORE Dao_QByteArray_New( const char* _cp0 );
QByteArray* DAO_DLL_QTCORE Dao_QByteArray_New( const char* _cp0, int size );
QByteArray* DAO_DLL_QTCORE Dao_QByteArray_New( int size, Qt::Initialization _cp1 );
QByteArray* DAO_DLL_QTCORE Dao_QByteArray_New( int size, char c );


QByteArrayMatcher* DAO_DLL_QTCORE Dao_QByteArrayMatcher_New(  );
QByteArrayMatcher* DAO_DLL_QTCORE Dao_QByteArrayMatcher_New( const QByteArray &pattern );
QByteArrayMatcher* DAO_DLL_QTCORE Dao_QByteArrayMatcher_New( const QByteArrayMatcher &other );
QByteArrayMatcher* DAO_DLL_QTCORE Dao_QByteArrayMatcher_New( const char* pattern, int length );


QChar* DAO_DLL_QTCORE Dao_QChar_New(  );
QChar* DAO_DLL_QTCORE Dao_QChar_New( QChar::SpecialCharacter sc );
QChar* DAO_DLL_QTCORE Dao_QChar_New( QLatin1Char ch );
QChar* DAO_DLL_QTCORE Dao_QChar_New( int rc );
QChar* DAO_DLL_QTCORE Dao_QChar_New( short rc );
QChar* DAO_DLL_QTCORE Dao_QChar_New( uchar c, uchar r );
QChar* DAO_DLL_QTCORE Dao_QChar_New( uint rc );
QChar* DAO_DLL_QTCORE Dao_QChar_New( ushort rc );


QEvent* DAO_DLL_QTCORE Dao_QEvent_New( QEvent::Type type );


QChildEvent* DAO_DLL_QTCORE Dao_QChildEvent_New( QEvent::Type type, QObject* child );

QContiguousCacheData* DAO_DLL_QTCORE Dao_QContiguousCacheData_New();


void DAO_DLL_QTCORE Dao_QCoreApplication_InitSS( QCoreApplication *p );
class DAO_DLL_QTCORE DaoSS_QCoreApplication :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QCoreApplication() : DaoSS_QObject() {}
public slots:
   void slot_quit511( void*, void*, const DaoQtMessage& );
   void slot_aboutToQuit709(  );
   void slot_unixSignal87( int _cp0 );

signals:
   void signal_quit511();
   void signal_aboutToQuit709(void*,const QString&,const DaoQtMessage&);
   void signal_unixSignal87(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QCoreApplication  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QCoreApplication(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QCoreApplication *self, DaoCData *d );
	QCoreApplication *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	bool compressEvent( int &_cs, QEvent* _cp0, QObject* receiver, QPostEventList* _cp2 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	bool notify( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QCoreApplication : public QCoreApplication, public DaoCxxVirt_QCoreApplication
{ Q_OBJECT
	public:
   DaoCxx_QCoreApplication( QCoreApplicationPrivate &p ) : QCoreApplication( p ){}
   DaoCxx_QCoreApplication( int& argc, char** argv ) : QCoreApplication( argc, argv ){}
	~DaoCxx_QCoreApplication();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	bool compressEvent( QEvent* _cp0, QObject* receiver, QPostEventList* _cp2 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	bool notify( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
	bool DaoWrap_compressEvent( QEvent* _cp0, QObject* receiver, QPostEventList* _cp2 ){ return QCoreApplication::compressEvent( _cp0, receiver, _cp2 ); }
	bool event( QEvent* _cp0 );
	bool DaoWrap_event( QEvent* _cp0 ){ return QCoreApplication::event( _cp0 ); }
};
DaoCxx_QCoreApplication* DAO_DLL_QTCORE DaoCxx_QCoreApplication_New( QCoreApplicationPrivate &p );
DaoCxx_QCoreApplication* DAO_DLL_QTCORE DaoCxx_QCoreApplication_New( int& argc, char** argv );


QCryptographicHash* DAO_DLL_QTCORE Dao_QCryptographicHash_New( QCryptographicHash::Algorithm method );


QDate* DAO_DLL_QTCORE Dao_QDate_New(  );
QDate* DAO_DLL_QTCORE Dao_QDate_New( int y, int m, int d );


QDateTime* DAO_DLL_QTCORE Dao_QDateTime_New(  );
QDateTime* DAO_DLL_QTCORE Dao_QDateTime_New( const QDate &_cp0 );
QDateTime* DAO_DLL_QTCORE Dao_QDateTime_New( const QDate &_cp0, const QTime &_cp1, Qt::TimeSpec spec );
QDateTime* DAO_DLL_QTCORE Dao_QDateTime_New( const QDateTime &other );


QDir* DAO_DLL_QTCORE Dao_QDir_New( const QDir &_cp0 );
QDir* DAO_DLL_QTCORE Dao_QDir_New( const QString &path );


QDirIterator* DAO_DLL_QTCORE Dao_QDirIterator_New( const QDir &dir, QDirIterator::IteratorFlags flags );
QDirIterator* DAO_DLL_QTCORE Dao_QDirIterator_New( const QString &path, QDir::Filters filter, QDirIterator::IteratorFlags flags );
QDirIterator* DAO_DLL_QTCORE Dao_QDirIterator_New( const QString &path, QDirIterator::IteratorFlags flags );
QDirIterator* DAO_DLL_QTCORE Dao_QDirIterator_New( const QString &path, const QStringList &nameFilters, QDir::Filters filters, QDirIterator::IteratorFlags flags );


QDynamicPropertyChangeEvent* DAO_DLL_QTCORE Dao_QDynamicPropertyChangeEvent_New( const QByteArray &name );


QEasingCurve* DAO_DLL_QTCORE Dao_QEasingCurve_New( QEasingCurve::Type type );
QEasingCurve* DAO_DLL_QTCORE Dao_QEasingCurve_New( const QEasingCurve &other );

QElapsedTimer* DAO_DLL_QTCORE Dao_QElapsedTimer_New();


void DAO_DLL_QTCORE Dao_QEventLoop_InitSS( QEventLoop *p );
class DAO_DLL_QTCORE DaoSS_QEventLoop :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QEventLoop() : DaoSS_QObject() {}
public slots:
   void slot_quit511( void*, void*, const DaoQtMessage& );

signals:
   void signal_quit511();
};
class DAO_DLL_QTCORE DaoCxxVirt_QEventLoop  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QEventLoop(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QEventLoop *self, DaoCData *d );
	QEventLoop *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QEventLoop : public QEventLoop, public DaoCxxVirt_QEventLoop
{ Q_OBJECT
	public:
   DaoCxx_QEventLoop( QObject* parent = 0 ) : QEventLoop( parent ){}
	~DaoCxx_QEventLoop();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
};
DaoCxx_QEventLoop* DAO_DLL_QTCORE DaoCxx_QEventLoop_New( QObject* parent );


void DAO_DLL_QTCORE Dao_QEventTransition_InitSS( QEventTransition *p );
class DAO_DLL_QTCORE DaoSS_QEventTransition :  public DaoSS_QAbstractTransition
{ Q_OBJECT
public:
	DaoSS_QEventTransition() : DaoSS_QAbstractTransition() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QEventTransition  : public DaoCxxVirt_QAbstractTransition
{
	public:
	DaoCxxVirt_QEventTransition(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QEventTransition *self, DaoCData *d );
	QEventTransition *self;
	DaoCData *cdata;

	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QEventTransition : public QEventTransition, public DaoCxxVirt_QEventTransition
{ Q_OBJECT
	public:
   DaoCxx_QEventTransition( QEventTransitionPrivate &dd, QObject* object, QEvent::Type type, QState* parent ) : QEventTransition( dd, object, type, parent ){}
   DaoCxx_QEventTransition( QEventTransitionPrivate &dd, QState* parent ) : QEventTransition( dd, parent ){}
   DaoCxx_QEventTransition( QObject* object, QEvent::Type type, QState* sourceState = 0 ) : QEventTransition( object, type, sourceState ){}
   DaoCxx_QEventTransition( QState* sourceState = 0 ) : QEventTransition( sourceState ){}
	~DaoCxx_QEventTransition();
	void DaoInitWrapper();
	bool event( QEvent* e );
	bool DaoWrap_event( QEvent* e ){ return QEventTransition::event( e ); }
	bool eventTest( QEvent* event );
	bool DaoWrap_eventTest( QEvent* event ){ return QEventTransition::eventTest( event ); }
	void onTransition( QEvent* event );
	void DaoWrap_onTransition( QEvent* event ){ QEventTransition::onTransition( event ); }
};
DaoCxx_QEventTransition* DAO_DLL_QTCORE DaoCxx_QEventTransition_New( QEventTransitionPrivate &dd, QObject* object, QEvent::Type type, QState* parent );
DaoCxx_QEventTransition* DAO_DLL_QTCORE DaoCxx_QEventTransition_New( QEventTransitionPrivate &dd, QState* parent );
DaoCxx_QEventTransition* DAO_DLL_QTCORE DaoCxx_QEventTransition_New( QObject* object, QEvent::Type type, QState* sourceState );
DaoCxx_QEventTransition* DAO_DLL_QTCORE DaoCxx_QEventTransition_New( QState* sourceState );

class DAO_DLL_QTCORE DaoCxxVirt_QFSFileEngine  : public DaoCxxVirt_QAbstractFileEngine
{
	public:
	DaoCxxVirt_QFSFileEngine(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QFSFileEngine *self, DaoCData *d );
	QFSFileEngine *self;
	DaoCData *cdata;
	bool extension( int &_cs, int extension, const QAbstractFileEngine::ExtensionOption* option, QAbstractFileEngine::ExtensionReturn* output );
	QAbstractFileEngine::FileFlags fileFlags( int &_cs, QAbstractFileEngine::FileFlags type )const;

};
class DAO_DLL_QTCORE DaoCxx_QFSFileEngine : public QFSFileEngine, public DaoCxxVirt_QFSFileEngine
{ 
	public:
   DaoCxx_QFSFileEngine(  ) : QFSFileEngine(  ){}
   DaoCxx_QFSFileEngine( QFSFileEnginePrivate &dd ) : QFSFileEngine( dd ){}
   DaoCxx_QFSFileEngine( const QString &file ) : QFSFileEngine( file ){}
	~DaoCxx_QFSFileEngine();
	void DaoInitWrapper();
	bool extension( QAbstractFileEngine::Extension extension, const QAbstractFileEngine::ExtensionOption* option = 0, QAbstractFileEngine::ExtensionReturn* output = 0 );
	QAbstractFileEngine::FileFlags fileFlags( QAbstractFileEngine::FileFlags type=FileInfoAll )const;
	QFSFileEngine::Iterator* beginEntryList( QDir::Filters filters, const QStringList &filterNames );
	bool caseSensitive(  )const;
	bool close(  );
	bool copy( const QString &newName );
	QFSFileEngine::Iterator* endEntryList(  );
	QStringList entryList( QDir::Filters filters, const QStringList &filterNames )const;
	QString fileName( QAbstractFileEngine::FileName file )const;
	QDateTime fileTime( QAbstractFileEngine::FileTime time )const;
	bool flush(  );
	int handle(  )const;
	bool isRelativePath(  )const;
	bool isSequential(  )const;
	bool link( const QString &newName );
	bool mkdir( const QString &dirName, bool createParentDirectories )const;
	bool open( QIODevice::OpenMode openMode );
	QString owner( QAbstractFileEngine::FileOwner _cp0 )const;
	uint ownerId( QAbstractFileEngine::FileOwner _cp0 )const;
	qint64 pos(  )const;
	qint64 read( char* data, qint64 maxlen );
	qint64 readLine( char* data, qint64 maxlen );
	bool remove(  );
	bool rename( const QString &newName );
	bool rmdir( const QString &dirName, bool recurseParentDirectories )const;
	bool seek( qint64 _cp0 );
	void setFileName( const QString &file );
	bool setPermissions( uint perms );
	bool setSize( qint64 size );
	qint64 size(  )const;
	bool supportsExtension( QAbstractFileEngine::Extension extens_EXCLUDE_ )const;
	qint64 write( const char* data, qint64 len );
};
DaoCxx_QFSFileEngine* DAO_DLL_QTCORE DaoCxx_QFSFileEngine_New(  );
DaoCxx_QFSFileEngine* DAO_DLL_QTCORE DaoCxx_QFSFileEngine_New( QFSFileEnginePrivate &dd );
DaoCxx_QFSFileEngine* DAO_DLL_QTCORE DaoCxx_QFSFileEngine_New( const QString &file );

class DAO_DLL_QTCORE DaoCxxVirt_QFactoryInterface 
{
	public:
	DaoCxxVirt_QFactoryInterface(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QFactoryInterface *self, DaoCData *d );
	QFactoryInterface *self;
	DaoCData *cdata;
	QStringList keys( int &_cs  )const;

};
class DAO_DLL_QTCORE DaoCxx_QFactoryInterface : public QFactoryInterface, public DaoCxxVirt_QFactoryInterface
{ 
	public:
	~DaoCxx_QFactoryInterface();
	void DaoInitWrapper();
	QStringList keys(  )const;
};
DaoCxx_QFactoryInterface* DAO_DLL_QTCORE DaoCxx_QFactoryInterface_New(  );


void DAO_DLL_QTCORE Dao_QFile_InitSS( QFile *p );
class DAO_DLL_QTCORE DaoSS_QFile :  public DaoSS_QIODevice
{ Q_OBJECT
public:
	DaoSS_QFile() : DaoSS_QIODevice() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QFile  : public DaoCxxVirt_QIODevice
{
	public:
	DaoCxxVirt_QFile(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QFile *self, DaoCData *d );
	QFile *self;
	DaoCData *cdata;
	qint64 bytesAvailable( int &_cs  )const;
	qint64 bytesToWrite( int &_cs  )const;
	bool canReadLine( int &_cs  )const;
	void close( int &_cs  );
	QAbstractFileEngine* fileEngine( int &_cs  )const;
	bool open( int &_cs, QIODevice::OpenMode mode );
	bool reset( int &_cs  );
	bool waitForBytesWritten( int &_cs, int msecs );
	bool waitForReadyRead( int &_cs, int msecs );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QFile : public QFile, public DaoCxxVirt_QFile
{ Q_OBJECT
	public:
   DaoCxx_QFile(  ) : QFile(  ){}
   DaoCxx_QFile( QFilePrivate &dd, QObject* parent = 0 ) : QFile( dd, parent ){}
   DaoCxx_QFile( QObject* parent ) : QFile( parent ){}
   DaoCxx_QFile( const QString &name ) : QFile( name ){}
   DaoCxx_QFile( const QString &name, QObject* parent ) : QFile( name, parent ){}
	~DaoCxx_QFile();
	void DaoInitWrapper();
	qint64 bytesAvailable(  )const;
	qint64 bytesToWrite(  )const;
	bool canReadLine(  )const;
	void close(  );
	QAbstractFileEngine* fileEngine(  )const;
	bool open( QIODevice::OpenMode mode );
	bool reset(  );
	bool waitForBytesWritten( int msecs );
	bool waitForReadyRead( int msecs );
	bool atEnd(  )const;
	bool isSequential(  )const;
	qint64 pos(  )const;
	qint64 readData( char* data, qint64 maxlen );
	qint64 DaoWrap_readData( char* data, qint64 maxlen ){ return QFile::readData( data, maxlen ); }
	qint64 readLineData( char* data, qint64 maxlen );
	qint64 DaoWrap_readLineData( char* data, qint64 maxlen ){ return QFile::readLineData( data, maxlen ); }
	bool seek( qint64 offset );
	qint64 size(  )const;
	qint64 writeData( const char* data, qint64 len );
	qint64 DaoWrap_writeData( const char* data, qint64 len ){ return QFile::writeData( data, len ); }
};
DaoCxx_QFile* DAO_DLL_QTCORE DaoCxx_QFile_New(  );
DaoCxx_QFile* DAO_DLL_QTCORE DaoCxx_QFile_New( QFilePrivate &dd, QObject* parent );
DaoCxx_QFile* DAO_DLL_QTCORE DaoCxx_QFile_New( QObject* parent );
DaoCxx_QFile* DAO_DLL_QTCORE DaoCxx_QFile_New( const QString &name );
DaoCxx_QFile* DAO_DLL_QTCORE DaoCxx_QFile_New( const QString &name, QObject* parent );


QFileInfo* DAO_DLL_QTCORE Dao_QFileInfo_New(  );
QFileInfo* DAO_DLL_QTCORE Dao_QFileInfo_New( const QDir &dir, const QString &file );
QFileInfo* DAO_DLL_QTCORE Dao_QFileInfo_New( const QFile &file );
QFileInfo* DAO_DLL_QTCORE Dao_QFileInfo_New( const QFileInfo &fileinfo );
QFileInfo* DAO_DLL_QTCORE Dao_QFileInfo_New( const QString &file );


void DAO_DLL_QTCORE Dao_QFileSystemWatcher_InitSS( QFileSystemWatcher *p );
class DAO_DLL_QTCORE DaoSS_QFileSystemWatcher :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QFileSystemWatcher() : DaoSS_QObject() {}
public slots:
   void slot_fileChanged290( const QString &path );
   void slot_directoryChanged746( const QString &path );

signals:
   void signal_fileChanged290(void*,const QString&,const DaoQtMessage&);
   void signal_directoryChanged746(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QFileSystemWatcher  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QFileSystemWatcher(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QFileSystemWatcher *self, DaoCData *d );
	QFileSystemWatcher *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QFileSystemWatcher : public QFileSystemWatcher, public DaoCxxVirt_QFileSystemWatcher
{ Q_OBJECT
	public:
   DaoCxx_QFileSystemWatcher( QObject* parent = 0 ) : QFileSystemWatcher( parent ){}
   DaoCxx_QFileSystemWatcher( const QStringList &paths, QObject* parent = 0 ) : QFileSystemWatcher( paths, parent ){}
	~DaoCxx_QFileSystemWatcher();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
};
DaoCxx_QFileSystemWatcher* DAO_DLL_QTCORE DaoCxx_QFileSystemWatcher_New( QObject* parent );
DaoCxx_QFileSystemWatcher* DAO_DLL_QTCORE DaoCxx_QFileSystemWatcher_New( const QStringList &paths, QObject* parent );


void DAO_DLL_QTCORE Dao_QFinalState_InitSS( QFinalState *p );
class DAO_DLL_QTCORE DaoSS_QFinalState :  public DaoSS_QAbstractState
{ Q_OBJECT
public:
	DaoSS_QFinalState() : DaoSS_QAbstractState() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QFinalState  : public DaoCxxVirt_QAbstractState
{
	public:
	DaoCxxVirt_QFinalState(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QFinalState *self, DaoCData *d );
	QFinalState *self;
	DaoCData *cdata;

	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QFinalState : public QFinalState, public DaoCxxVirt_QFinalState
{ Q_OBJECT
	public:
   DaoCxx_QFinalState( QState* parent = 0 ) : QFinalState( parent ){}
	~DaoCxx_QFinalState();
	void DaoInitWrapper();
	bool event( QEvent* e );
	bool DaoWrap_event( QEvent* e ){ return QFinalState::event( e ); }
	void onEntry( QEvent* event );
	void DaoWrap_onEntry( QEvent* event ){ QFinalState::onEntry( event ); }
	void onExit( QEvent* event );
	void DaoWrap_onExit( QEvent* event ){ QFinalState::onExit( event ); }
};
DaoCxx_QFinalState* DAO_DLL_QTCORE DaoCxx_QFinalState_New( QState* parent );


QFutureInterfaceBase* DAO_DLL_QTCORE Dao_QFutureInterfaceBase_New( QFutureInterfaceBase::State initialState );
QFutureInterfaceBase* DAO_DLL_QTCORE Dao_QFutureInterfaceBase_New( const QFutureInterfaceBase &other );


class DAO_DLL_QTCORE DaoSS_QFutureWatcherBase :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QFutureWatcherBase() : DaoSS_QObject() {}
public slots:
   void slot_cancel431( void*, void*, const DaoQtMessage& );
   void slot_setPaused773( void*, void*, const DaoQtMessage& );
   void slot_pause555( void*, void*, const DaoQtMessage& );
   void slot_resume427( void*, void*, const DaoQtMessage& );
   void slot_togglePaused91( void*, void*, const DaoQtMessage& );
   void slot_started757(  );
   void slot_finished719(  );
   void slot_canceled114(  );
   void slot_paused475(  );
   void slot_resumed496(  );
   void slot_resultReadyAt357( int resultIndex );
   void slot_resultsReadyAt181( int beginIndex, int endIndex );
   void slot_progressRangeChanged503( int minimum, int maximum );
   void slot_progressValueChanged255( int progressValue );
   void slot_progressTextChanged384( const QString &progressText );

signals:
   void signal_cancel431();
   void signal_setPaused773(bool);
   void signal_pause555();
   void signal_resume427();
   void signal_togglePaused91();
   void signal_started757(void*,const QString&,const DaoQtMessage&);
   void signal_finished719(void*,const QString&,const DaoQtMessage&);
   void signal_canceled114(void*,const QString&,const DaoQtMessage&);
   void signal_paused475(void*,const QString&,const DaoQtMessage&);
   void signal_resumed496(void*,const QString&,const DaoQtMessage&);
   void signal_resultReadyAt357(void*,const QString&,const DaoQtMessage&);
   void signal_resultsReadyAt181(void*,const QString&,const DaoQtMessage&);
   void signal_progressRangeChanged503(void*,const QString&,const DaoQtMessage&);
   void signal_progressValueChanged255(void*,const QString&,const DaoQtMessage&);
   void signal_progressTextChanged384(void*,const QString&,const DaoQtMessage&);
};


QGenericArgument* DAO_DLL_QTCORE Dao_QGenericArgument_New( const char* aName, const void* aData );


QGenericReturnArgument* DAO_DLL_QTCORE Dao_QGenericReturnArgument_New( const char* aName, void* aData );

QHashData* DAO_DLL_QTCORE Dao_QHashData_New();

QHashDummyValue* DAO_DLL_QTCORE Dao_QHashDummyValue_New();


void DAO_DLL_QTCORE Dao_QHistoryState_InitSS( QHistoryState *p );
class DAO_DLL_QTCORE DaoSS_QHistoryState :  public DaoSS_QAbstractState
{ Q_OBJECT
public:
	DaoSS_QHistoryState() : DaoSS_QAbstractState() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QHistoryState  : public DaoCxxVirt_QAbstractState
{
	public:
	DaoCxxVirt_QHistoryState(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QHistoryState *self, DaoCData *d );
	QHistoryState *self;
	DaoCData *cdata;

	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QHistoryState : public QHistoryState, public DaoCxxVirt_QHistoryState
{ Q_OBJECT
	public:
   DaoCxx_QHistoryState( QHistoryState::HistoryType type, QState* parent = 0 ) : QHistoryState( type, parent ){}
   DaoCxx_QHistoryState( QState* parent = 0 ) : QHistoryState( parent ){}
	~DaoCxx_QHistoryState();
	void DaoInitWrapper();
	bool event( QEvent* e );
	bool DaoWrap_event( QEvent* e ){ return QHistoryState::event( e ); }
	void onEntry( QEvent* event );
	void DaoWrap_onEntry( QEvent* event ){ QHistoryState::onEntry( event ); }
	void onExit( QEvent* event );
	void DaoWrap_onExit( QEvent* event ){ QHistoryState::onExit( event ); }
};
DaoCxx_QHistoryState* DAO_DLL_QTCORE DaoCxx_QHistoryState_New( QHistoryState::HistoryType type, QState* parent );
DaoCxx_QHistoryState* DAO_DLL_QTCORE DaoCxx_QHistoryState_New( QState* parent );


QLatin1Char* DAO_DLL_QTCORE Dao_QLatin1Char_New( char c );


QLatin1String* DAO_DLL_QTCORE Dao_QLatin1String_New( const char* s );


void DAO_DLL_QTCORE Dao_QLibrary_InitSS( QLibrary *p );
class DAO_DLL_QTCORE DaoSS_QLibrary :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QLibrary() : DaoSS_QObject() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QLibrary  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QLibrary(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QLibrary *self, DaoCData *d );
	QLibrary *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QLibrary : public QLibrary, public DaoCxxVirt_QLibrary
{ Q_OBJECT
	public:
   DaoCxx_QLibrary( QObject* parent = 0 ) : QLibrary( parent ){}
   DaoCxx_QLibrary( const QString &fileName, QObject* parent = 0 ) : QLibrary( fileName, parent ){}
   DaoCxx_QLibrary( const QString &fileName, const QString &version, QObject* parent = 0 ) : QLibrary( fileName, version, parent ){}
   DaoCxx_QLibrary( const QString &fileName, int verNum, QObject* parent = 0 ) : QLibrary( fileName, verNum, parent ){}
	~DaoCxx_QLibrary();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
};
DaoCxx_QLibrary* DAO_DLL_QTCORE DaoCxx_QLibrary_New( QObject* parent );
DaoCxx_QLibrary* DAO_DLL_QTCORE DaoCxx_QLibrary_New( const QString &fileName, QObject* parent );
DaoCxx_QLibrary* DAO_DLL_QTCORE DaoCxx_QLibrary_New( const QString &fileName, const QString &version, QObject* parent );
DaoCxx_QLibrary* DAO_DLL_QTCORE DaoCxx_QLibrary_New( const QString &fileName, int verNum, QObject* parent );


QLine* DAO_DLL_QTCORE Dao_QLine_New(  );
QLine* DAO_DLL_QTCORE Dao_QLine_New( const QPoint &pt1, const QPoint &pt2 );
QLine* DAO_DLL_QTCORE Dao_QLine_New( int x1, int y1, int x2, int y2 );


QLineF* DAO_DLL_QTCORE Dao_QLineF_New(  );
QLineF* DAO_DLL_QTCORE Dao_QLineF_New( const QLine &line );
QLineF* DAO_DLL_QTCORE Dao_QLineF_New( const QPointF &pt1, const QPointF &pt2 );
QLineF* DAO_DLL_QTCORE Dao_QLineF_New( qreal x1, qreal y1, qreal x2, qreal y2 );

QLinkedListData* DAO_DLL_QTCORE Dao_QLinkedListData_New();

QListData* DAO_DLL_QTCORE Dao_QListData_New();


QLocale* DAO_DLL_QTCORE Dao_QLocale_New(  );
QLocale* DAO_DLL_QTCORE Dao_QLocale_New( QLocale::Language language, QLocale::Country country );
QLocale* DAO_DLL_QTCORE Dao_QLocale_New( const QLocale &other );
QLocale* DAO_DLL_QTCORE Dao_QLocale_New( const QString &name );

QMapData* DAO_DLL_QTCORE Dao_QMapData_New();


QMetaClassInfo* DAO_DLL_QTCORE Dao_QMetaClassInfo_New(  );


QMetaEnum* DAO_DLL_QTCORE Dao_QMetaEnum_New(  );


QMetaMethod* DAO_DLL_QTCORE Dao_QMetaMethod_New(  );

QMetaObject* DAO_DLL_QTCORE Dao_QMetaObject_New();

QMetaObjectExtraData* DAO_DLL_QTCORE Dao_QMetaObjectExtraData_New();


QMetaProperty* DAO_DLL_QTCORE Dao_QMetaProperty_New(  );

QMetaType* DAO_DLL_QTCORE Dao_QMetaType_New();


void DAO_DLL_QTCORE Dao_QMimeData_InitSS( QMimeData *p );
class DAO_DLL_QTCORE DaoSS_QMimeData :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QMimeData() : DaoSS_QObject() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QMimeData  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QMimeData(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QMimeData *self, DaoCData *d );
	QMimeData *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	QStringList formats( int &_cs  )const;
	bool hasFormat( int &_cs, const QString &mimetype )const;
	QVariant retrieveData( int &_cs, const QString &mimetype, QVariant::Type preferredType )const;
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QMimeData : public QMimeData, public DaoCxxVirt_QMimeData
{ Q_OBJECT
	public:
   DaoCxx_QMimeData(  ) : QMimeData(  ){}
	~DaoCxx_QMimeData();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	QStringList formats(  )const;
	bool hasFormat( const QString &mimetype )const;
	QVariant retrieveData( const QString &mimetype, QVariant::Type preferredType )const;
	void timerEvent( QTimerEvent* _cp0 );
	QVariant DaoWrap_retrieveData( const QString &mimetype, QVariant::Type preferredType )const{ return QMimeData::retrieveData( mimetype, preferredType ); }
};
DaoCxx_QMimeData* DAO_DLL_QTCORE DaoCxx_QMimeData_New(  );


QModelIndex* DAO_DLL_QTCORE Dao_QModelIndex_New(  );
QModelIndex* DAO_DLL_QTCORE Dao_QModelIndex_New( const QModelIndex &other );

QModelIndexList* DAO_DLL_QTCORE Dao_QModelIndexList_New();


QMutex* DAO_DLL_QTCORE Dao_QMutex_New( QMutex::RecursionMode mode );


QMutexLocker* DAO_DLL_QTCORE Dao_QMutexLocker_New( QMutex* m );


void DAO_DLL_QTCORE Dao_QObjectCleanupHandler_InitSS( QObjectCleanupHandler *p );
class DAO_DLL_QTCORE DaoSS_QObjectCleanupHandler :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QObjectCleanupHandler() : DaoSS_QObject() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QObjectCleanupHandler  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QObjectCleanupHandler(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QObjectCleanupHandler *self, DaoCData *d );
	QObjectCleanupHandler *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QObjectCleanupHandler : public QObjectCleanupHandler, public DaoCxxVirt_QObjectCleanupHandler
{ Q_OBJECT
	public:
   DaoCxx_QObjectCleanupHandler(  ) : QObjectCleanupHandler(  ){}
	~DaoCxx_QObjectCleanupHandler();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
};
DaoCxx_QObjectCleanupHandler* DAO_DLL_QTCORE DaoCxx_QObjectCleanupHandler_New(  );


void DAO_DLL_QTCORE Dao_QParallelAnimationGroup_InitSS( QParallelAnimationGroup *p );
class DAO_DLL_QTCORE DaoSS_QParallelAnimationGroup :  public DaoSS_QAnimationGroup
{ Q_OBJECT
public:
	DaoSS_QParallelAnimationGroup() : DaoSS_QAnimationGroup() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QParallelAnimationGroup  : public DaoCxxVirt_QAnimationGroup
{
	public:
	DaoCxxVirt_QParallelAnimationGroup(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QParallelAnimationGroup *self, DaoCData *d );
	QParallelAnimationGroup *self;
	DaoCData *cdata;

	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QParallelAnimationGroup : public QParallelAnimationGroup, public DaoCxxVirt_QParallelAnimationGroup
{ Q_OBJECT
	public:
   DaoCxx_QParallelAnimationGroup( QObject* parent = 0 ) : QParallelAnimationGroup( parent ){}
   DaoCxx_QParallelAnimationGroup( QParallelAnimationGroupPrivate &dd, QObject* parent ) : QParallelAnimationGroup( dd, parent ){}
	~DaoCxx_QParallelAnimationGroup();
	void DaoInitWrapper();
	int duration(  )const;
	bool event( QEvent* event );
	bool DaoWrap_event( QEvent* event ){ return QParallelAnimationGroup::event( event ); }
	void updateCurrentTime( int currentTime );
	void DaoWrap_updateCurrentTime( int currentTime ){ QParallelAnimationGroup::updateCurrentTime( currentTime ); }
	void updateDirection( QAbstractAnimation::Direction direction );
	void DaoWrap_updateDirection( QAbstractAnimation::Direction direction ){ QParallelAnimationGroup::updateDirection( direction ); }
	void updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState );
	void DaoWrap_updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState ){ QParallelAnimationGroup::updateState( newState, oldState ); }
};
DaoCxx_QParallelAnimationGroup* DAO_DLL_QTCORE DaoCxx_QParallelAnimationGroup_New( QObject* parent );
DaoCxx_QParallelAnimationGroup* DAO_DLL_QTCORE DaoCxx_QParallelAnimationGroup_New( QParallelAnimationGroupPrivate &dd, QObject* parent );


void DAO_DLL_QTCORE Dao_QPauseAnimation_InitSS( QPauseAnimation *p );
class DAO_DLL_QTCORE DaoSS_QPauseAnimation :  public DaoSS_QAbstractAnimation
{ Q_OBJECT
public:
	DaoSS_QPauseAnimation() : DaoSS_QAbstractAnimation() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QPauseAnimation  : public DaoCxxVirt_QAbstractAnimation
{
	public:
	DaoCxxVirt_QPauseAnimation(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QPauseAnimation *self, DaoCData *d );
	QPauseAnimation *self;
	DaoCData *cdata;
	void updateDirection( int &_cs, QAbstractAnimation::Direction direction );
	void updateState( int &_cs, QAbstractAnimation::State newState, QAbstractAnimation::State oldState );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QPauseAnimation : public QPauseAnimation, public DaoCxxVirt_QPauseAnimation
{ Q_OBJECT
	public:
   DaoCxx_QPauseAnimation( QObject* parent = 0 ) : QPauseAnimation( parent ){}
   DaoCxx_QPauseAnimation( int msecs, QObject* parent = 0 ) : QPauseAnimation( msecs, parent ){}
	~DaoCxx_QPauseAnimation();
	void DaoInitWrapper();
	void updateDirection( QAbstractAnimation::Direction direction );
	void updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState );
	int duration(  )const;
	bool event( QEvent* e );
	bool DaoWrap_event( QEvent* e ){ return QPauseAnimation::event( e ); }
	void updateCurrentTime( int _cp0 );
	void DaoWrap_updateCurrentTime( int _cp0 ){ QPauseAnimation::updateCurrentTime( _cp0 ); }
};
DaoCxx_QPauseAnimation* DAO_DLL_QTCORE DaoCxx_QPauseAnimation_New( QObject* parent );
DaoCxx_QPauseAnimation* DAO_DLL_QTCORE DaoCxx_QPauseAnimation_New( int msecs, QObject* parent );


QPersistentModelIndex* DAO_DLL_QTCORE Dao_QPersistentModelIndex_New(  );
QPersistentModelIndex* DAO_DLL_QTCORE Dao_QPersistentModelIndex_New( const QModelIndex &index );
QPersistentModelIndex* DAO_DLL_QTCORE Dao_QPersistentModelIndex_New( const QPersistentModelIndex &other );


void DAO_DLL_QTCORE Dao_QPluginLoader_InitSS( QPluginLoader *p );
class DAO_DLL_QTCORE DaoSS_QPluginLoader :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QPluginLoader() : DaoSS_QObject() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QPluginLoader  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QPluginLoader(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QPluginLoader *self, DaoCData *d );
	QPluginLoader *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QPluginLoader : public QPluginLoader, public DaoCxxVirt_QPluginLoader
{ Q_OBJECT
	public:
   DaoCxx_QPluginLoader( QObject* parent = 0 ) : QPluginLoader( parent ){}
   DaoCxx_QPluginLoader( const QString &fileName, QObject* parent = 0 ) : QPluginLoader( fileName, parent ){}
	~DaoCxx_QPluginLoader();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
};
DaoCxx_QPluginLoader* DAO_DLL_QTCORE DaoCxx_QPluginLoader_New( QObject* parent );
DaoCxx_QPluginLoader* DAO_DLL_QTCORE DaoCxx_QPluginLoader_New( const QString &fileName, QObject* parent );


QPoint* DAO_DLL_QTCORE Dao_QPoint_New(  );
QPoint* DAO_DLL_QTCORE Dao_QPoint_New( int xpos, int ypos );


QPointF* DAO_DLL_QTCORE Dao_QPointF_New(  );
QPointF* DAO_DLL_QTCORE Dao_QPointF_New( const QPoint &p );
QPointF* DAO_DLL_QTCORE Dao_QPointF_New( qreal xpos, qreal ypos );


void DAO_DLL_QTCORE Dao_QProcess_InitSS( QProcess *p );
class DAO_DLL_QTCORE DaoSS_QProcess :  public DaoSS_QIODevice
{ Q_OBJECT
public:
	DaoSS_QProcess() : DaoSS_QIODevice() {}
public slots:
   void slot_terminate366( void*, void*, const DaoQtMessage& );
   void slot_kill350( void*, void*, const DaoQtMessage& );
   void slot_started757(  );
   void slot_finished320( int exitCode );
   void slot_finished299( int exitCode, QProcess::ExitStatus exitStatus );
   void slot_error560( QProcess::ProcessError error );
   void slot_stateChanged991( QProcess::ProcessState state );
   void slot_readyReadStandardOutput708(  );
   void slot_readyReadStandardError500(  );

signals:
   void signal_terminate366();
   void signal_kill350();
   void signal_started757(void*,const QString&,const DaoQtMessage&);
   void signal_finished320(void*,const QString&,const DaoQtMessage&);
   void signal_finished299(void*,const QString&,const DaoQtMessage&);
   void signal_error560(void*,const QString&,const DaoQtMessage&);
   void signal_stateChanged991(void*,const QString&,const DaoQtMessage&);
   void signal_readyReadStandardOutput708(void*,const QString&,const DaoQtMessage&);
   void signal_readyReadStandardError500(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QProcess  : public DaoCxxVirt_QIODevice
{
	public:
	DaoCxxVirt_QProcess(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QProcess *self, DaoCData *d );
	QProcess *self;
	DaoCData *cdata;
	bool open( int &_cs, QIODevice::OpenMode mode );
	qint64 pos( int &_cs  )const;
	qint64 readLineData( int &_cs, char* data, qint64 maxlen );
	bool reset( int &_cs  );
	bool seek( int &_cs, qint64 pos );
	void setupChildProcess( int &_cs  );
	qint64 size( int &_cs  )const;
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QProcess : public QProcess, public DaoCxxVirt_QProcess
{ Q_OBJECT
	public:
   DaoCxx_QProcess( QObject* parent = 0 ) : QProcess( parent ){}
	~DaoCxx_QProcess();
	void DaoInitWrapper();
	bool open( QIODevice::OpenMode mode );
	qint64 pos(  )const;
	qint64 readLineData( char* data, qint64 maxlen );
	bool reset(  );
	bool seek( qint64 pos );
	void setupChildProcess(  );
	qint64 size(  )const;
	bool atEnd(  )const;
	qint64 bytesAvailable(  )const;
	qint64 bytesToWrite(  )const;
	bool canReadLine(  )const;
	void close(  );
	bool isSequential(  )const;
	qint64 readData( char* data, qint64 maxlen );
	qint64 DaoWrap_readData( char* data, qint64 maxlen ){ return QProcess::readData( data, maxlen ); }
	void DaoWrap_setProcessState( QProcess::ProcessState state ){ QProcess::setProcessState( state ); }
	void DaoWrap_setupChildProcess(  ){ QProcess::setupChildProcess(  ); }
	bool waitForBytesWritten( int msecs );
	bool waitForReadyRead( int msecs );
	qint64 writeData( const char* data, qint64 len );
	qint64 DaoWrap_writeData( const char* data, qint64 len ){ return QProcess::writeData( data, len ); }
};
DaoCxx_QProcess* DAO_DLL_QTCORE DaoCxx_QProcess_New( QObject* parent );


QProcessEnvironment* DAO_DLL_QTCORE Dao_QProcessEnvironment_New(  );
QProcessEnvironment* DAO_DLL_QTCORE Dao_QProcessEnvironment_New( const QProcessEnvironment &other );


void DAO_DLL_QTCORE Dao_QVariantAnimation_InitSS( QVariantAnimation *p );
class DAO_DLL_QTCORE DaoSS_QVariantAnimation :  public DaoSS_QAbstractAnimation
{ Q_OBJECT
public:
	DaoSS_QVariantAnimation() : DaoSS_QAbstractAnimation() {}
public slots:
   void slot_valueChanged592( const QVariant &value );

signals:
   void signal_valueChanged592(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QVariantAnimation  : public DaoCxxVirt_QAbstractAnimation
{
	public:
	DaoCxxVirt_QVariantAnimation(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QVariantAnimation *self, DaoCData *d );
	QVariantAnimation *self;
	DaoCData *cdata;
	QVariant interpolated( int &_cs, const QVariant &from, const QVariant &to, qreal progress )const;
	void updateCurrentValue( int &_cs, const QVariant &value );
	void updateDirection( int &_cs, QAbstractAnimation::Direction direction );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QVariantAnimation : public QVariantAnimation, public DaoCxxVirt_QVariantAnimation
{ Q_OBJECT
	public:
   DaoCxx_QVariantAnimation( QObject* parent = 0 ) : QVariantAnimation( parent ){}
   DaoCxx_QVariantAnimation( QVariantAnimationPrivate &dd, QObject* parent = 0 ) : QVariantAnimation( dd, parent ){}
	~DaoCxx_QVariantAnimation();
	void DaoInitWrapper();
	QVariant interpolated( const QVariant &from, const QVariant &to, qreal progress )const;
	void updateCurrentValue( const QVariant &value );
	void updateDirection( QAbstractAnimation::Direction direction );
	int duration(  )const;
	bool event( QEvent* event );
	bool DaoWrap_event( QEvent* event ){ return QVariantAnimation::event( event ); }
	QVariant DaoWrap_interpolated( const QVariant &from, const QVariant &to, qreal progress )const{ return QVariantAnimation::interpolated( from, to, progress ); }
	void updateCurrentTime( int _cp0 );
	void DaoWrap_updateCurrentTime( int _cp0 ){ QVariantAnimation::updateCurrentTime( _cp0 ); }
	void DaoWrap_updateCurrentValue( const QVariant &value ){ QVariantAnimation::updateCurrentValue( value ); }
	void updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState );
	void DaoWrap_updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState ){ QVariantAnimation::updateState( newState, oldState ); }
};
DaoCxx_QVariantAnimation* DAO_DLL_QTCORE DaoCxx_QVariantAnimation_New( QObject* parent );
DaoCxx_QVariantAnimation* DAO_DLL_QTCORE DaoCxx_QVariantAnimation_New( QVariantAnimationPrivate &dd, QObject* parent );


void DAO_DLL_QTCORE Dao_QPropertyAnimation_InitSS( QPropertyAnimation *p );
class DAO_DLL_QTCORE DaoSS_QPropertyAnimation :  public DaoSS_QVariantAnimation
{ Q_OBJECT
public:
	DaoSS_QPropertyAnimation() : DaoSS_QVariantAnimation() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QPropertyAnimation  : public DaoCxxVirt_QVariantAnimation
{
	public:
	DaoCxxVirt_QPropertyAnimation(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QPropertyAnimation *self, DaoCData *d );
	QPropertyAnimation *self;
	DaoCData *cdata;
	QVariant interpolated( int &_cs, const QVariant &from, const QVariant &to, qreal progress )const;
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QPropertyAnimation : public QPropertyAnimation, public DaoCxxVirt_QPropertyAnimation
{ Q_OBJECT
	public:
   DaoCxx_QPropertyAnimation( QObject* parent = 0 ) : QPropertyAnimation( parent ){}
   DaoCxx_QPropertyAnimation( QObject* target, const QByteArray &propertyName, QObject* parent = 0 ) : QPropertyAnimation( target, propertyName, parent ){}
	~DaoCxx_QPropertyAnimation();
	void DaoInitWrapper();
	QVariant interpolated( const QVariant &from, const QVariant &to, qreal progress )const;
	bool event( QEvent* event );
	bool DaoWrap_event( QEvent* event ){ return QPropertyAnimation::event( event ); }
	void updateCurrentValue( const QVariant &value );
	void DaoWrap_updateCurrentValue( const QVariant &value ){ QPropertyAnimation::updateCurrentValue( value ); }
	void updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState );
	void DaoWrap_updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState ){ QPropertyAnimation::updateState( newState, oldState ); }
};
DaoCxx_QPropertyAnimation* DAO_DLL_QTCORE DaoCxx_QPropertyAnimation_New( QObject* parent );
DaoCxx_QPropertyAnimation* DAO_DLL_QTCORE DaoCxx_QPropertyAnimation_New( QObject* target, const QByteArray &propertyName, QObject* parent );


QReadLocker* DAO_DLL_QTCORE Dao_QReadLocker_New( QReadWriteLock* readWriteLock );


QReadWriteLock* DAO_DLL_QTCORE Dao_QReadWriteLock_New(  );
QReadWriteLock* DAO_DLL_QTCORE Dao_QReadWriteLock_New( QReadWriteLock::RecursionMode recursionMode );


QRect* DAO_DLL_QTCORE Dao_QRect_New(  );
QRect* DAO_DLL_QTCORE Dao_QRect_New( const QPoint &topleft, const QPoint &bottomright );
QRect* DAO_DLL_QTCORE Dao_QRect_New( const QPoint &topleft, const QSize &size );
QRect* DAO_DLL_QTCORE Dao_QRect_New( int left, int top, int width, int height );


QRectF* DAO_DLL_QTCORE Dao_QRectF_New(  );
QRectF* DAO_DLL_QTCORE Dao_QRectF_New( const QPointF &topleft, const QPointF &bottomRight );
QRectF* DAO_DLL_QTCORE Dao_QRectF_New( const QPointF &topleft, const QSizeF &size );
QRectF* DAO_DLL_QTCORE Dao_QRectF_New( const QRect &rect );
QRectF* DAO_DLL_QTCORE Dao_QRectF_New( qreal left, qreal top, qreal width, qreal height );


QRegExp* DAO_DLL_QTCORE Dao_QRegExp_New(  );
QRegExp* DAO_DLL_QTCORE Dao_QRegExp_New( const QRegExp &rx );
QRegExp* DAO_DLL_QTCORE Dao_QRegExp_New( const QString &pattern, Qt::CaseSensitivity cs, QRegExp::PatternSyntax syntax );


QResource* DAO_DLL_QTCORE Dao_QResource_New( const QString &file, const QLocale &locale );

QScopedPointerPodDeleter* DAO_DLL_QTCORE Dao_QScopedPointerPodDeleter_New();


QSemaphore* DAO_DLL_QTCORE Dao_QSemaphore_New( int n );


void DAO_DLL_QTCORE Dao_QSequentialAnimationGroup_InitSS( QSequentialAnimationGroup *p );
class DAO_DLL_QTCORE DaoSS_QSequentialAnimationGroup :  public DaoSS_QAnimationGroup
{ Q_OBJECT
public:
	DaoSS_QSequentialAnimationGroup() : DaoSS_QAnimationGroup() {}
public slots:
   void slot_currentAnimationChanged950( QAbstractAnimation* current );

signals:
   void signal_currentAnimationChanged950(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QSequentialAnimationGroup  : public DaoCxxVirt_QAnimationGroup
{
	public:
	DaoCxxVirt_QSequentialAnimationGroup(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QSequentialAnimationGroup *self, DaoCData *d );
	QSequentialAnimationGroup *self;
	DaoCData *cdata;

	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QSequentialAnimationGroup : public QSequentialAnimationGroup, public DaoCxxVirt_QSequentialAnimationGroup
{ Q_OBJECT
	public:
   DaoCxx_QSequentialAnimationGroup( QObject* parent = 0 ) : QSequentialAnimationGroup( parent ){}
   DaoCxx_QSequentialAnimationGroup( QSequentialAnimationGroupPrivate &dd, QObject* parent ) : QSequentialAnimationGroup( dd, parent ){}
	~DaoCxx_QSequentialAnimationGroup();
	void DaoInitWrapper();
	int duration(  )const;
	bool event( QEvent* event );
	bool DaoWrap_event( QEvent* event ){ return QSequentialAnimationGroup::event( event ); }
	void updateCurrentTime( int _cp0 );
	void DaoWrap_updateCurrentTime( int _cp0 ){ QSequentialAnimationGroup::updateCurrentTime( _cp0 ); }
	void updateDirection( QAbstractAnimation::Direction direction );
	void DaoWrap_updateDirection( QAbstractAnimation::Direction direction ){ QSequentialAnimationGroup::updateDirection( direction ); }
	void updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState );
	void DaoWrap_updateState( QAbstractAnimation::State newState, QAbstractAnimation::State oldState ){ QSequentialAnimationGroup::updateState( newState, oldState ); }
};
DaoCxx_QSequentialAnimationGroup* DAO_DLL_QTCORE DaoCxx_QSequentialAnimationGroup_New( QObject* parent );
DaoCxx_QSequentialAnimationGroup* DAO_DLL_QTCORE DaoCxx_QSequentialAnimationGroup_New( QSequentialAnimationGroupPrivate &dd, QObject* parent );


void DAO_DLL_QTCORE Dao_QSettings_InitSS( QSettings *p );
class DAO_DLL_QTCORE DaoSS_QSettings :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QSettings() : DaoSS_QObject() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QSettings  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QSettings(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QSettings *self, DaoCData *d );
	QSettings *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QSettings : public QSettings, public DaoCxxVirt_QSettings
{ Q_OBJECT
	public:
   DaoCxx_QSettings( QObject* parent = 0 ) : QSettings( parent ){}
   DaoCxx_QSettings( QSettings::Format format, QSettings::Scope scope, const QString &organization, const QString &application =0, QObject* parent = 0 ) : QSettings( format, scope, organization, application, parent ){}
   DaoCxx_QSettings( QSettings::Scope scope, const QString &organization, const QString &application =0, QObject* parent = 0 ) : QSettings( scope, organization, application, parent ){}
   DaoCxx_QSettings( const QString &fileName, QSettings::Format format, QObject* parent = 0 ) : QSettings( fileName, format, parent ){}
   DaoCxx_QSettings( const QString &organization, const QString &application =0, QObject* parent = 0 ) : QSettings( organization, application, parent ){}
	~DaoCxx_QSettings();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
	bool event( QEvent* event );
	bool DaoWrap_event( QEvent* event ){ return QSettings::event( event ); }
};
DaoCxx_QSettings* DAO_DLL_QTCORE DaoCxx_QSettings_New( QObject* parent );
DaoCxx_QSettings* DAO_DLL_QTCORE DaoCxx_QSettings_New( QSettings::Format format, QSettings::Scope scope, const QString &organization, const QString &application, QObject* parent );
DaoCxx_QSettings* DAO_DLL_QTCORE DaoCxx_QSettings_New( QSettings::Scope scope, const QString &organization, const QString &application, QObject* parent );
DaoCxx_QSettings* DAO_DLL_QTCORE DaoCxx_QSettings_New( const QString &fileName, QSettings::Format format, QObject* parent );
DaoCxx_QSettings* DAO_DLL_QTCORE DaoCxx_QSettings_New( const QString &organization, const QString &application, QObject* parent );


QSharedData* DAO_DLL_QTCORE Dao_QSharedData_New(  );
QSharedData* DAO_DLL_QTCORE Dao_QSharedData_New( const QSharedData &_cp0 );


void DAO_DLL_QTCORE Dao_QSharedMemory_InitSS( QSharedMemory *p );
class DAO_DLL_QTCORE DaoSS_QSharedMemory :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QSharedMemory() : DaoSS_QObject() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QSharedMemory  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QSharedMemory(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QSharedMemory *self, DaoCData *d );
	QSharedMemory *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QSharedMemory : public QSharedMemory, public DaoCxxVirt_QSharedMemory
{ Q_OBJECT
	public:
   DaoCxx_QSharedMemory( QObject* parent = 0 ) : QSharedMemory( parent ){}
   DaoCxx_QSharedMemory( const QString &key, QObject* parent = 0 ) : QSharedMemory( key, parent ){}
	~DaoCxx_QSharedMemory();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
};
DaoCxx_QSharedMemory* DAO_DLL_QTCORE DaoCxx_QSharedMemory_New( QObject* parent );
DaoCxx_QSharedMemory* DAO_DLL_QTCORE DaoCxx_QSharedMemory_New( const QString &key, QObject* parent );


void DAO_DLL_QTCORE Dao_QSignalTransition_InitSS( QSignalTransition *p );
class DAO_DLL_QTCORE DaoSS_QSignalTransition :  public DaoSS_QAbstractTransition
{ Q_OBJECT
public:
	DaoSS_QSignalTransition() : DaoSS_QAbstractTransition() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QSignalTransition  : public DaoCxxVirt_QAbstractTransition
{
	public:
	DaoCxxVirt_QSignalTransition(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QSignalTransition *self, DaoCData *d );
	QSignalTransition *self;
	DaoCData *cdata;

	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QSignalTransition : public QSignalTransition, public DaoCxxVirt_QSignalTransition
{ Q_OBJECT
	public:
   DaoCxx_QSignalTransition( QObject* sender, const char* signal, QState* sourceState = 0 ) : QSignalTransition( sender, signal, sourceState ){}
   DaoCxx_QSignalTransition( QState* sourceState = 0 ) : QSignalTransition( sourceState ){}
	~DaoCxx_QSignalTransition();
	void DaoInitWrapper();
	bool event( QEvent* e );
	bool DaoWrap_event( QEvent* e ){ return QSignalTransition::event( e ); }
	bool eventTest( QEvent* event );
	bool DaoWrap_eventTest( QEvent* event ){ return QSignalTransition::eventTest( event ); }
	void onTransition( QEvent* event );
	void DaoWrap_onTransition( QEvent* event ){ QSignalTransition::onTransition( event ); }
};
DaoCxx_QSignalTransition* DAO_DLL_QTCORE DaoCxx_QSignalTransition_New( QObject* sender, const char* signal, QState* sourceState );
DaoCxx_QSignalTransition* DAO_DLL_QTCORE DaoCxx_QSignalTransition_New( QState* sourceState );


QSize* DAO_DLL_QTCORE Dao_QSize_New(  );
QSize* DAO_DLL_QTCORE Dao_QSize_New( int w, int h );


QSizeF* DAO_DLL_QTCORE Dao_QSizeF_New(  );
QSizeF* DAO_DLL_QTCORE Dao_QSizeF_New( const QSize &sz );
QSizeF* DAO_DLL_QTCORE Dao_QSizeF_New( qreal w, qreal h );


void DAO_DLL_QTCORE Dao_QSocketNotifier_InitSS( QSocketNotifier *p );
class DAO_DLL_QTCORE DaoSS_QSocketNotifier :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QSocketNotifier() : DaoSS_QObject() {}
public slots:
   void slot_setEnabled37( void*, void*, const DaoQtMessage& );
   void slot_activated900( int socket );

signals:
   void signal_setEnabled37(bool);
   void signal_activated900(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QSocketNotifier  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QSocketNotifier(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QSocketNotifier *self, DaoCData *d );
	QSocketNotifier *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QSocketNotifier : public QSocketNotifier, public DaoCxxVirt_QSocketNotifier
{ Q_OBJECT
	public:
   DaoCxx_QSocketNotifier( int socket, QSocketNotifier::Type _cp1, QObject* parent = 0 ) : QSocketNotifier( socket, _cp1, parent ){}
	~DaoCxx_QSocketNotifier();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
	bool event( QEvent* _cp0 );
	bool DaoWrap_event( QEvent* _cp0 ){ return QSocketNotifier::event( _cp0 ); }
};
DaoCxx_QSocketNotifier* DAO_DLL_QTCORE DaoCxx_QSocketNotifier_New( int socket, QSocketNotifier::Type _cp1, QObject* parent );


void DAO_DLL_QTCORE Dao_QState_InitSS( QState *p );
class DAO_DLL_QTCORE DaoSS_QState :  public DaoSS_QAbstractState
{ Q_OBJECT
public:
	DaoSS_QState() : DaoSS_QAbstractState() {}
public slots:
   void slot_finished719(  );
   void slot_propertiesAssigned686(  );

signals:
   void signal_finished719(void*,const QString&,const DaoQtMessage&);
   void signal_propertiesAssigned686(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QState  : public DaoCxxVirt_QAbstractState
{
	public:
	DaoCxxVirt_QState(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QState *self, DaoCData *d );
	QState *self;
	DaoCData *cdata;

	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QState : public QState, public DaoCxxVirt_QState
{ Q_OBJECT
	public:
   DaoCxx_QState( QState* parent = 0 ) : QState( parent ){}
   DaoCxx_QState( QState::ChildMode childMode, QState* parent = 0 ) : QState( childMode, parent ){}
   DaoCxx_QState( QStatePrivate &dd, QState* parent ) : QState( dd, parent ){}
	~DaoCxx_QState();
	void DaoInitWrapper();
	bool event( QEvent* e );
	bool DaoWrap_event( QEvent* e ){ return QState::event( e ); }
	void onEntry( QEvent* event );
	void DaoWrap_onEntry( QEvent* event ){ QState::onEntry( event ); }
	void onExit( QEvent* event );
	void DaoWrap_onExit( QEvent* event ){ QState::onExit( event ); }
};
DaoCxx_QState* DAO_DLL_QTCORE DaoCxx_QState_New( QState* parent );
DaoCxx_QState* DAO_DLL_QTCORE DaoCxx_QState_New( QState::ChildMode childMode, QState* parent );
DaoCxx_QState* DAO_DLL_QTCORE DaoCxx_QState_New( QStatePrivate &dd, QState* parent );


void DAO_DLL_QTCORE Dao_QStateMachine_InitSS( QStateMachine *p );
class DAO_DLL_QTCORE DaoSS_QStateMachine :  public DaoSS_QState
{ Q_OBJECT
public:
	DaoSS_QStateMachine() : DaoSS_QState() {}
public slots:
   void slot_start907( void*, void*, const DaoQtMessage& );
   void slot_stop638( void*, void*, const DaoQtMessage& );
   void slot_started757(  );
   void slot_stopped551(  );

signals:
   void signal_start907();
   void signal_stop638();
   void signal_started757(void*,const QString&,const DaoQtMessage&);
   void signal_stopped551(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QStateMachine  : public DaoCxxVirt_QState
{
	public:
	DaoCxxVirt_QStateMachine(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QStateMachine *self, DaoCData *d );
	QStateMachine *self;
	DaoCData *cdata;
	void beginMicrostep( int &_cs, QEvent* event );
	void beginSelectTransitions( int &_cs, QEvent* event );
	void endMicrostep( int &_cs, QEvent* event );
	void endSelectTransitions( int &_cs, QEvent* event );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QStateMachine : public QStateMachine, public DaoCxxVirt_QStateMachine
{ Q_OBJECT
	public:
   DaoCxx_QStateMachine( QObject* parent = 0 ) : QStateMachine( parent ){}
   DaoCxx_QStateMachine( QStateMachinePrivate &dd, QObject* parent ) : QStateMachine( dd, parent ){}
	~DaoCxx_QStateMachine();
	void DaoInitWrapper();
	void beginMicrostep( QEvent* event );
	void beginSelectTransitions( QEvent* event );
	void endMicrostep( QEvent* event );
	void endSelectTransitions( QEvent* event );
	void DaoWrap_beginMicrostep( QEvent* event ){ QStateMachine::beginMicrostep( event ); }
	void DaoWrap_beginSelectTransitions( QEvent* event ){ QStateMachine::beginSelectTransitions( event ); }
	void DaoWrap_endMicrostep( QEvent* event ){ QStateMachine::endMicrostep( event ); }
	void DaoWrap_endSelectTransitions( QEvent* event ){ QStateMachine::endSelectTransitions( event ); }
	bool event( QEvent* e );
	bool DaoWrap_event( QEvent* e ){ return QStateMachine::event( e ); }
	bool eventFilter( QObject* watched, QEvent* event );
	void onEntry( QEvent* event );
	void DaoWrap_onEntry( QEvent* event ){ QStateMachine::onEntry( event ); }
	void onExit( QEvent* event );
	void DaoWrap_onExit( QEvent* event ){ QStateMachine::onExit( event ); }
};
DaoCxx_QStateMachine* DAO_DLL_QTCORE DaoCxx_QStateMachine_New( QObject* parent );
DaoCxx_QStateMachine* DAO_DLL_QTCORE DaoCxx_QStateMachine_New( QStateMachinePrivate &dd, QObject* parent );


QString* DAO_DLL_QTCORE Dao_QString_New(  );
QString* DAO_DLL_QTCORE Dao_QString_New( QChar ch );
QString* DAO_DLL_QTCORE Dao_QString_New( const QChar* unicode );
QString* DAO_DLL_QTCORE Dao_QString_New( const QChar* unicode, int size );
QString* DAO_DLL_QTCORE Dao_QString_New( const QLatin1String &latin1 );
QString* DAO_DLL_QTCORE Dao_QString_New( const QString &_cp0 );
QString* DAO_DLL_QTCORE Dao_QString_New( const QString::Null &_cp0 );
QString* DAO_DLL_QTCORE Dao_QString_New( const char* chs );
QString* DAO_DLL_QTCORE Dao_QString_New( int size, QChar c );
QString* DAO_DLL_QTCORE Dao_QString_New( int size, Qt::Initialization _cp1 );


QStringList* DAO_DLL_QTCORE Dao_QStringList_New(  );
QStringList* DAO_DLL_QTCORE Dao_QStringList_New( const QString &i );
QStringList* DAO_DLL_QTCORE Dao_QStringList_New( const QStringList &l );


QStringMatcher* DAO_DLL_QTCORE Dao_QStringMatcher_New(  );
QStringMatcher* DAO_DLL_QTCORE Dao_QStringMatcher_New( const QChar* uc, int len, Qt::CaseSensitivity cs );
QStringMatcher* DAO_DLL_QTCORE Dao_QStringMatcher_New( const QString &pattern, Qt::CaseSensitivity cs );
QStringMatcher* DAO_DLL_QTCORE Dao_QStringMatcher_New( const QStringMatcher &other );

class DAO_DLL_QTCORE DaoCxxVirt_QSystemLocale 
{
	public:
	DaoCxxVirt_QSystemLocale(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QSystemLocale *self, DaoCData *d );
	QSystemLocale *self;
	DaoCData *cdata;
	QLocale fallbackLocale( int &_cs  )const;
	QVariant query( int &_cs, int type, QVariant in )const;

};
class DAO_DLL_QTCORE DaoCxx_QSystemLocale : public QSystemLocale, public DaoCxxVirt_QSystemLocale
{ 
	public:
   DaoCxx_QSystemLocale(  ) : QSystemLocale(  ){}
	~DaoCxx_QSystemLocale();
	void DaoInitWrapper();
	QLocale fallbackLocale(  )const;
	QVariant query( QSystemLocale::QueryType type, QVariant in )const;
};
QSystemLocale* Dao_QSystemLocale_Copy( const QSystemLocale &p );
DaoCxx_QSystemLocale* DAO_DLL_QTCORE DaoCxx_QSystemLocale_New(  );


QSystemSemaphore* DAO_DLL_QTCORE Dao_QSystemSemaphore_New( const QString &key, int initialValue, QSystemSemaphore::AccessMode mode );


void DAO_DLL_QTCORE Dao_QTemporaryFile_InitSS( QTemporaryFile *p );
class DAO_DLL_QTCORE DaoSS_QTemporaryFile :  public DaoSS_QFile
{ Q_OBJECT
public:
	DaoSS_QTemporaryFile() : DaoSS_QFile() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QTemporaryFile  : public DaoCxxVirt_QFile
{
	public:
	DaoCxxVirt_QTemporaryFile(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QTemporaryFile *self, DaoCData *d );
	QTemporaryFile *self;
	DaoCData *cdata;
	void close( int &_cs  );
	QAbstractFileEngine* fileEngine( int &_cs  )const;
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QTemporaryFile : public QTemporaryFile, public DaoCxxVirt_QTemporaryFile
{ Q_OBJECT
	public:
   DaoCxx_QTemporaryFile(  ) : QTemporaryFile(  ){}
   DaoCxx_QTemporaryFile( QObject* parent ) : QTemporaryFile( parent ){}
   DaoCxx_QTemporaryFile( const QString &templateName ) : QTemporaryFile( templateName ){}
   DaoCxx_QTemporaryFile( const QString &templateName, QObject* parent ) : QTemporaryFile( templateName, parent ){}
	~DaoCxx_QTemporaryFile();
	void DaoInitWrapper();
	void close(  );
	QAbstractFileEngine* fileEngine(  )const;
	bool DaoWrap_open( QTemporaryFile::OpenMode flags ){ return QTemporaryFile::open( flags ); }
};
DaoCxx_QTemporaryFile* DAO_DLL_QTCORE DaoCxx_QTemporaryFile_New(  );
DaoCxx_QTemporaryFile* DAO_DLL_QTCORE DaoCxx_QTemporaryFile_New( QObject* parent );
DaoCxx_QTemporaryFile* DAO_DLL_QTCORE DaoCxx_QTemporaryFile_New( const QString &templateName );
DaoCxx_QTemporaryFile* DAO_DLL_QTCORE DaoCxx_QTemporaryFile_New( const QString &templateName, QObject* parent );


QTextBoundaryFinder* DAO_DLL_QTCORE Dao_QTextBoundaryFinder_New(  );
QTextBoundaryFinder* DAO_DLL_QTCORE Dao_QTextBoundaryFinder_New( QTextBoundaryFinder::BoundaryType type, const QChar* chars, int length, unsigned char* buffer, int bufferSize );
QTextBoundaryFinder* DAO_DLL_QTCORE Dao_QTextBoundaryFinder_New( QTextBoundaryFinder::BoundaryType type, const QString &string );
QTextBoundaryFinder* DAO_DLL_QTCORE Dao_QTextBoundaryFinder_New( const QTextBoundaryFinder &other );

class DAO_DLL_QTCORE DaoCxxVirt_QTextCodec 
{
	public:
	DaoCxxVirt_QTextCodec(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QTextCodec *self, DaoCData *d );
	QTextCodec *self;
	DaoCData *cdata;
	QByteArray convertFromUnicode( int &_cs, const QChar* in, int length, QTextCodec::ConverterState* state )const;
	QString convertToUnicode( int &_cs, const char* in, int length, QTextCodec::ConverterState* state )const;
	int mibEnum( int &_cs  )const;
	QByteArray name( int &_cs  )const;

};
class DAO_DLL_QTCORE DaoCxx_QTextCodec : public QTextCodec, public DaoCxxVirt_QTextCodec
{ 
	public:
   DaoCxx_QTextCodec(  ) : QTextCodec(  ){}
	~DaoCxx_QTextCodec();
	void DaoInitWrapper();
	QByteArray convertFromUnicode( const QChar* in, int length, QTextCodec::ConverterState* state )const;
	QString convertToUnicode( const char* in, int length, QTextCodec::ConverterState* state )const;
	int mibEnum(  )const;
	QByteArray name(  )const;
	QByteArray DaoWrap_convertFromUnicode( const QChar* in, int length, QTextCodec::ConverterState* state )const{ return QTextCodec::convertFromUnicode( in, length, state ); }
	QString DaoWrap_convertToUnicode( const char* in, int length, QTextCodec::ConverterState* state )const{ return QTextCodec::convertToUnicode( in, length, state ); }
};
DaoCxx_QTextCodec* DAO_DLL_QTCORE DaoCxx_QTextCodec_New(  );

class DAO_DLL_QTCORE DaoCxxVirt_QTextCodecFactoryInterface  : public DaoCxxVirt_QFactoryInterface
{
	public:
	DaoCxxVirt_QTextCodecFactoryInterface(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QTextCodecFactoryInterface *self, DaoCData *d );
	QTextCodecFactoryInterface *self;
	DaoCData *cdata;
	QTextCodec* create( int &_cs, const QString &key );
	QStringList keys( int &_cs  )const;

};
class DAO_DLL_QTCORE DaoCxx_QTextCodecFactoryInterface : public QTextCodecFactoryInterface, public DaoCxxVirt_QTextCodecFactoryInterface
{ 
	public:
	~DaoCxx_QTextCodecFactoryInterface();
	void DaoInitWrapper();
	QTextCodec* create( const QString &key );
	QStringList keys(  )const;
};
DaoCxx_QTextCodecFactoryInterface* DAO_DLL_QTCORE DaoCxx_QTextCodecFactoryInterface_New(  );


void DAO_DLL_QTCORE Dao_QTextCodecPlugin_InitSS( QTextCodecPlugin *p );
class DAO_DLL_QTCORE DaoSS_QTextCodecPlugin :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QTextCodecPlugin() : DaoSS_QObject() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QTextCodecPlugin  : public DaoCxxVirt_QObject, public DaoCxxVirt_QTextCodecFactoryInterface
{
	public:
	DaoCxxVirt_QTextCodecPlugin(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QTextCodecPlugin *self, DaoCData *d );
	QTextCodecPlugin *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	QTextCodec* createForMib( int &_cs, int mib );
	QTextCodec* createForName( int &_cs, const QByteArray &name );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QTextCodecPlugin : public QTextCodecPlugin, public DaoCxxVirt_QTextCodecPlugin
{ Q_OBJECT
	public:
   DaoCxx_QTextCodecPlugin( QObject* parent = 0 ) : QTextCodecPlugin( parent ){}
	~DaoCxx_QTextCodecPlugin();
	void DaoInitWrapper();
  QList<QByteArray> aliases()const{/*XXX 1*/}
  QList<QByteArray> names()const{/*XXX 1*/}
  QList<int> mibEnums()const{/*XXX 1*/}
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	QTextCodec* createForMib( int mib );
	QTextCodec* createForName( const QByteArray &name );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
};
DaoCxx_QTextCodecPlugin* DAO_DLL_QTCORE DaoCxx_QTextCodecPlugin_New( QObject* parent );


QTextDecoder* DAO_DLL_QTCORE Dao_QTextDecoder_New( const QTextCodec* codec );
QTextDecoder* DAO_DLL_QTCORE Dao_QTextDecoder_New( const QTextCodec* codec, QTextCodec::ConversionFlags flags );


QTextEncoder* DAO_DLL_QTCORE Dao_QTextEncoder_New( const QTextCodec* codec );
QTextEncoder* DAO_DLL_QTCORE Dao_QTextEncoder_New( const QTextCodec* codec, QTextCodec::ConversionFlags flags );


QTextStream* DAO_DLL_QTCORE Dao_QTextStream_New(  );
QTextStream* DAO_DLL_QTCORE Dao_QTextStream_New( FILE* fileHandle, QIODevice::OpenMode openMode );
QTextStream* DAO_DLL_QTCORE Dao_QTextStream_New( QByteArray* array, QIODevice::OpenMode openMode );
QTextStream* DAO_DLL_QTCORE Dao_QTextStream_New( QIODevice* device );
QTextStream* DAO_DLL_QTCORE Dao_QTextStream_New( QString* string, QIODevice::OpenMode openMode );
QTextStream* DAO_DLL_QTCORE Dao_QTextStream_New( const QByteArray &array, QIODevice::OpenMode openMode );


QTextStreamManipulator* DAO_DLL_QTCORE Dao_QTextStreamManipulator_New( QTSMFC m, QChar c );
QTextStreamManipulator* DAO_DLL_QTCORE Dao_QTextStreamManipulator_New( QTSMFI m, int a );


void DAO_DLL_QTCORE Dao_QThread_InitSS( QThread *p );
class DAO_DLL_QTCORE DaoSS_QThread :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QThread() : DaoSS_QObject() {}
public slots:
   void slot_start73( void*, void*, const DaoQtMessage& );
   void slot_terminate366( void*, void*, const DaoQtMessage& );
   void slot_quit511( void*, void*, const DaoQtMessage& );
   void slot_started757(  );
   void slot_finished719(  );
   void slot_terminated381(  );

signals:
   void signal_start73(QThread::Priority);
   void signal_terminate366();
   void signal_quit511();
   void signal_started757(void*,const QString&,const DaoQtMessage&);
   void signal_finished719(void*,const QString&,const DaoQtMessage&);
   void signal_terminated381(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QThread  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QThread(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QThread *self, DaoCData *d );
	QThread *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void run( int &_cs  );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QThread : public QThread, public DaoCxxVirt_QThread
{ Q_OBJECT
	public:
   DaoCxx_QThread( QObject* parent = 0 ) : QThread( parent ){}
   DaoCxx_QThread( QThreadPrivate &dd, QObject* parent = 0 ) : QThread( dd, parent ){}
	~DaoCxx_QThread();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void run(  );
	void timerEvent( QTimerEvent* _cp0 );
	int DaoWrap_exec(  ){ return QThread::exec(  ); }
	void DaoWrap_msleep( unsigned long _cp0 ){ QThread::msleep( _cp0 ); }
	void DaoWrap_run(  ){ QThread::run(  ); }
	void DaoWrap_setTerminationEnabled( bool enabled = true ){ QThread::setTerminationEnabled( enabled ); }
	void DaoWrap_sleep( unsigned long _cp0 ){ QThread::sleep( _cp0 ); }
	void DaoWrap_usleep( unsigned long _cp0 ){ QThread::usleep( _cp0 ); }
};
DaoCxx_QThread* DAO_DLL_QTCORE DaoCxx_QThread_New( QObject* parent );
DaoCxx_QThread* DAO_DLL_QTCORE DaoCxx_QThread_New( QThreadPrivate &dd, QObject* parent );


void DAO_DLL_QTCORE Dao_QThreadPool_InitSS( QThreadPool *p );
class DAO_DLL_QTCORE DaoSS_QThreadPool :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QThreadPool() : DaoSS_QObject() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QThreadPool  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QThreadPool(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QThreadPool *self, DaoCData *d );
	QThreadPool *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QThreadPool : public QThreadPool, public DaoCxxVirt_QThreadPool
{ Q_OBJECT
	public:
   DaoCxx_QThreadPool( QObject* parent = 0 ) : QThreadPool( parent ){}
	~DaoCxx_QThreadPool();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
};
DaoCxx_QThreadPool* DAO_DLL_QTCORE DaoCxx_QThreadPool_New( QObject* parent );


QTime* DAO_DLL_QTCORE Dao_QTime_New(  );
QTime* DAO_DLL_QTCORE Dao_QTime_New( int h, int m, int s, int ms );


void DAO_DLL_QTCORE Dao_QTimeLine_InitSS( QTimeLine *p );
class DAO_DLL_QTCORE DaoSS_QTimeLine :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QTimeLine() : DaoSS_QObject() {}
public slots:
   void slot_start907( void*, void*, const DaoQtMessage& );
   void slot_resume427( void*, void*, const DaoQtMessage& );
   void slot_stop638( void*, void*, const DaoQtMessage& );
   void slot_setPaused773( void*, void*, const DaoQtMessage& );
   void slot_setCurrentTime670( void*, void*, const DaoQtMessage& );
   void slot_toggleDirection484( void*, void*, const DaoQtMessage& );
   void slot_valueChanged43( qreal x );
   void slot_frameChanged160( int _cp0 );
   void slot_stateChanged150( QTimeLine::State newState );
   void slot_finished719(  );

signals:
   void signal_start907();
   void signal_resume427();
   void signal_stop638();
   void signal_setPaused773(bool);
   void signal_setCurrentTime670(int);
   void signal_toggleDirection484();
   void signal_valueChanged43(void*,const QString&,const DaoQtMessage&);
   void signal_frameChanged160(void*,const QString&,const DaoQtMessage&);
   void signal_stateChanged150(void*,const QString&,const DaoQtMessage&);
   void signal_finished719(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QTimeLine  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QTimeLine(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QTimeLine *self, DaoCData *d );
	QTimeLine *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	qreal valueForTime( int &_cs, int msec )const;
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QTimeLine : public QTimeLine, public DaoCxxVirt_QTimeLine
{ Q_OBJECT
	public:
   DaoCxx_QTimeLine( int duration = 1000, QObject* parent = 0 ) : QTimeLine( duration, parent ){}
	~DaoCxx_QTimeLine();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	qreal valueForTime( int msec )const;
	void timerEvent( QTimerEvent* event );
	void DaoWrap_timerEvent( QTimerEvent* event ){ QTimeLine::timerEvent( event ); }
};
DaoCxx_QTimeLine* DAO_DLL_QTCORE DaoCxx_QTimeLine_New( int duration, QObject* parent );


void DAO_DLL_QTCORE Dao_QTimer_InitSS( QTimer *p );
class DAO_DLL_QTCORE DaoSS_QTimer :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QTimer() : DaoSS_QObject() {}
public slots:
   void slot_start10( void*, void*, const DaoQtMessage& );
   void slot_start907( void*, void*, const DaoQtMessage& );
   void slot_stop638( void*, void*, const DaoQtMessage& );
   void slot_timeout9(  );

signals:
   void signal_start10(int);
   void signal_start907();
   void signal_stop638();
   void signal_timeout9(void*,const QString&,const DaoQtMessage&);
};
class DAO_DLL_QTCORE DaoCxxVirt_QTimer  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QTimer(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QTimer *self, DaoCData *d );
	QTimer *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QTimer : public QTimer, public DaoCxxVirt_QTimer
{ Q_OBJECT
	public:
   DaoCxx_QTimer( QObject* parent = 0 ) : QTimer( parent ){}
	~DaoCxx_QTimer();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	void timerEvent( QTimerEvent* _cp0 );
	void DaoWrap_timerEvent( QTimerEvent* _cp0 ){ QTimer::timerEvent( _cp0 ); }
};
DaoCxx_QTimer* DAO_DLL_QTCORE DaoCxx_QTimer_New( QObject* parent );


QTimerEvent* DAO_DLL_QTCORE Dao_QTimerEvent_New( int timerId );


void DAO_DLL_QTCORE Dao_QTranslator_InitSS( QTranslator *p );
class DAO_DLL_QTCORE DaoSS_QTranslator :  public DaoSS_QObject
{ Q_OBJECT
public:
	DaoSS_QTranslator() : DaoSS_QObject() {}
public slots:
signals:

};
class DAO_DLL_QTCORE DaoCxxVirt_QTranslator  : public DaoCxxVirt_QObject
{
	public:
	DaoCxxVirt_QTranslator(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QTranslator *self, DaoCData *d );
	QTranslator *self;
	DaoCData *cdata;
	void childEvent( int &_cs, QChildEvent* _cp0 );
	void connectNotify( int &_cs, const char* signal );
	void customEvent( int &_cs, QEvent* _cp0 );
	void disconnectNotify( int &_cs, const char* signal );
	bool event( int &_cs, QEvent* _cp0 );
	bool eventFilter( int &_cs, QObject* _cp0, QEvent* _cp1 );
	bool isEmpty( int &_cs  )const;
	void timerEvent( int &_cs, QTimerEvent* _cp0 );
	QString translate( int &_cs, const char* context, const char* sourceText, const char* disambiguation )const;
	virtual void Emit( void *o, void *s, const DaoQtMessage &m ){}
};
class DAO_DLL_QTCORE DaoCxx_QTranslator : public QTranslator, public DaoCxxVirt_QTranslator
{ Q_OBJECT
	public:
   DaoCxx_QTranslator( QObject* parent = 0 ) : QTranslator( parent ){}
	~DaoCxx_QTranslator();
	void DaoInitWrapper();
	void childEvent( QChildEvent* _cp0 );
	void connectNotify( const char* signal );
	void customEvent( QEvent* _cp0 );
	void disconnectNotify( const char* signal );
	bool event( QEvent* _cp0 );
	bool eventFilter( QObject* _cp0, QEvent* _cp1 );
	bool isEmpty(  )const;
	void timerEvent( QTimerEvent* _cp0 );
	QString translate( const char* context, const char* sourceText, const char* disambiguation = 0 )const;
};
DaoCxx_QTranslator* DAO_DLL_QTCORE DaoCxx_QTranslator_New( QObject* parent );


QUrl* DAO_DLL_QTCORE Dao_QUrl_New(  );
QUrl* DAO_DLL_QTCORE Dao_QUrl_New( const QString &url );
QUrl* DAO_DLL_QTCORE Dao_QUrl_New( const QString &url, QUrl::ParsingMode mode );
QUrl* DAO_DLL_QTCORE Dao_QUrl_New( const QUrl &copy );


QUuid* DAO_DLL_QTCORE Dao_QUuid_New(  );
QUuid* DAO_DLL_QTCORE Dao_QUuid_New( const QString &_cp0 );
QUuid* DAO_DLL_QTCORE Dao_QUuid_New( const char* _cp0 );
QUuid* DAO_DLL_QTCORE Dao_QUuid_New( uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8 );


QVariant* DAO_DLL_QTCORE Dao_QVariant_New(  );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( QDataStream &s );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( QVariant::Type type );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( Qt::GlobalColor color );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( bool b );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QBitArray &bitarray );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QByteArray &bytearray );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QChar &qchar );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QDate &date );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QDateTime &datetime );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QEasingCurve &easing );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QLatin1String &string );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QLine &line );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QLineF &line );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QLocale &locale );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QPoint &pt );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QPointF &pt );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QRect &rect );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QRectF &rect );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QRegExp &regExp );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QSize &size );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QSizeF &size );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QString &string );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QStringList &stringlist );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QTime &time );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QUrl &url );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( const QVariant &other );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( double d );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( float f );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( int i );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( int typeOrUserType, const void* copy );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( int typeOrUserType, const void* copy, uint flags );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( qlonglong ll );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( qulonglong ull );
QVariant* DAO_DLL_QTCORE Dao_QVariant_New( uint ui );

QVectorData* DAO_DLL_QTCORE Dao_QVectorData_New();


QWaitCondition* DAO_DLL_QTCORE Dao_QWaitCondition_New(  );


QWriteLocker* DAO_DLL_QTCORE Dao_QWriteLocker_New( QReadWriteLock* readWriteLock );


QXmlStreamAttribute* DAO_DLL_QTCORE Dao_QXmlStreamAttribute_New(  );
QXmlStreamAttribute* DAO_DLL_QTCORE Dao_QXmlStreamAttribute_New( const QString &qualifiedName, const QString &value );
QXmlStreamAttribute* DAO_DLL_QTCORE Dao_QXmlStreamAttribute_New( const QString &namespaceUri, const QString &name, const QString &value );
QXmlStreamAttribute* DAO_DLL_QTCORE Dao_QXmlStreamAttribute_New( const QXmlStreamAttribute &_cp0 );

QXmlStreamAttributes* DAO_DLL_QTCORE Dao_QXmlStreamAttributes_New();


QXmlStreamEntityDeclaration* DAO_DLL_QTCORE Dao_QXmlStreamEntityDeclaration_New(  );
QXmlStreamEntityDeclaration* DAO_DLL_QTCORE Dao_QXmlStreamEntityDeclaration_New( const QXmlStreamEntityDeclaration &_cp0 );

class DAO_DLL_QTCORE DaoCxxVirt_QXmlStreamEntityResolver 
{
	public:
	DaoCxxVirt_QXmlStreamEntityResolver(){ self = 0; cdata = 0; }
	void DaoInitWrapper( QXmlStreamEntityResolver *self, DaoCData *d );
	QXmlStreamEntityResolver *self;
	DaoCData *cdata;
	QString resolveEntity( int &_cs, const QString &publicId, const QString &systemId );
	QString resolveUndeclaredEntity( int &_cs, const QString &name );

};
class DAO_DLL_QTCORE DaoCxx_QXmlStreamEntityResolver : public QXmlStreamEntityResolver, public DaoCxxVirt_QXmlStreamEntityResolver
{ 
	public:
	~DaoCxx_QXmlStreamEntityResolver();
	void DaoInitWrapper();
	QString resolveEntity( const QString &publicId, const QString &systemId );
	QString resolveUndeclaredEntity( const QString &name );
};
QXmlStreamEntityResolver* Dao_QXmlStreamEntityResolver_Copy( const QXmlStreamEntityResolver &p );
DaoCxx_QXmlStreamEntityResolver* DAO_DLL_QTCORE DaoCxx_QXmlStreamEntityResolver_New(  );


QXmlStreamNamespaceDeclaration* DAO_DLL_QTCORE Dao_QXmlStreamNamespaceDeclaration_New(  );
QXmlStreamNamespaceDeclaration* DAO_DLL_QTCORE Dao_QXmlStreamNamespaceDeclaration_New( const QString &prefix, const QString &namespaceUri );
QXmlStreamNamespaceDeclaration* DAO_DLL_QTCORE Dao_QXmlStreamNamespaceDeclaration_New( const QXmlStreamNamespaceDeclaration &_cp0 );


QXmlStreamNotationDeclaration* DAO_DLL_QTCORE Dao_QXmlStreamNotationDeclaration_New(  );
QXmlStreamNotationDeclaration* DAO_DLL_QTCORE Dao_QXmlStreamNotationDeclaration_New( const QXmlStreamNotationDeclaration &_cp0 );


QXmlStreamReader* DAO_DLL_QTCORE Dao_QXmlStreamReader_New(  );
QXmlStreamReader* DAO_DLL_QTCORE Dao_QXmlStreamReader_New( QIODevice* device );
QXmlStreamReader* DAO_DLL_QTCORE Dao_QXmlStreamReader_New( const QByteArray &data );
QXmlStreamReader* DAO_DLL_QTCORE Dao_QXmlStreamReader_New( const QString &data );
QXmlStreamReader* DAO_DLL_QTCORE Dao_QXmlStreamReader_New( const char* data );


QXmlStreamStringRef* DAO_DLL_QTCORE Dao_QXmlStreamStringRef_New(  );
QXmlStreamStringRef* DAO_DLL_QTCORE Dao_QXmlStreamStringRef_New( const QString &aString );
QXmlStreamStringRef* DAO_DLL_QTCORE Dao_QXmlStreamStringRef_New( const QStringRef &aString );


QXmlStreamWriter* DAO_DLL_QTCORE Dao_QXmlStreamWriter_New(  );
QXmlStreamWriter* DAO_DLL_QTCORE Dao_QXmlStreamWriter_New( QByteArray* array );
QXmlStreamWriter* DAO_DLL_QTCORE Dao_QXmlStreamWriter_New( QIODevice* device );
QXmlStreamWriter* DAO_DLL_QTCORE Dao_QXmlStreamWriter_New( QString* string );
namespace QtConcurrent{


ResultIteratorBase* DAO_DLL_QTCORE Dao_ResultIteratorBase_New(  );
}
namespace QtConcurrent{


ResultStoreBase* DAO_DLL_QTCORE Dao_ResultStoreBase_New(  );
}
DaoBase* DaoQt_Get_Wrapper( const QObject *object );

#endif
